I Haven't Told Anyone This, But...5b2e554

Sometime after midnight tonight, a lot of people will type "I haven't told anyone this, but..." into a chat window, and very few will think about where that sentence goes. Conversational AI feels like a confidant, but legally it is a service receiving data. Encryption, deletion, and training opt-outs reduce risk, but no privacy setting makes a conversation privileged, and a 2025 court order showed that even deleted chats can be preserved. We need a legal idea of confidential AI communication.

The Cost of Tokens817e2d9

Suppose an engineer tells their manager they need a bigger token budget because they can't keep working without it. It sounds like good news until you ask why the pull request has three retry wrappers and watch them paste the question into the agent. The bill is the visible cost of AI. The expensive token is the one spent replacing your own understanding. Write down how you work so the agent stops rediscovering it, keep the understanding with the people who get paged, and judge token spend by what it bought.

Most of Your Job Is Peoplefae5fac

The most frustrated person on a team is rarely the least competent one. More often it's someone good at the work who can't understand why everything around the work is so slow. Past basic competence, what separates the effective people from the stuck ones is mostly how they handle the people around the work: giving your boss the information they need, letting your team watch what good looks like, handing other teams a request they can say yes to, and permanently removing the problems that keep requiring you. Manage up, model down, and keep working yourself out of a job.

AI Doesn't Have to Make You a Faster Programmercaf1b9c

A good developer works with focus all day and closes three tickets, and nobody can point to the slow part, because the coding was quick. We keep measuring AI by speed at the keyboard, when the keyboard was rarely the constraint. AI does not have to make you a dramatically faster programmer to make your team dramatically faster; it just has to kill the cold-start hour every ticket demands before a single useful line gets written. Put an agent at the front of the line to investigate and open a draft pull request, and the developer stops starting every ticket from zero.

The Nuts and Bolts of a Modern MCP Servereb13844

I had a remote MCP server that worked with every client I pointed at it, until Grok's OAuth flow asked a discovery question no other client had asked and the integration stopped before a single tool call. The July 2026 MCP specification goes straight at that class of failure. The protocol is stateless over Streamable HTTP, discovery is explicit, OAuth discovery is hardened around RFC 9728, and MCP Apps let a tool return a sandboxed interface. MCP is turning into ordinary Internet infrastructure, and the interesting engineering starts after the JSON-RPC leaves your process.

Put Your Tokens Where Your Revenue Is144c4cd

Imagine two engineering teams with the same size, the same roles, and the same AI budget. A year later, one has cut delivery time by 40 percent; the other has a very impressive token dashboard. Most enterprise budgets would fund them identically next year, because technology budgeting is built around access and fairness. That model works for software licenses and breaks down with AI, because AI is productive capacity whose value depends on where it is applied. Give everyone baseline access, then manage the rest like an investment portfolio: measure outcomes at the team level and move capacity toward the teams that turn it into revenue.

The AI Execution Curve445ca81

There is a planning meeting most executives have never sat in, where nobody brings a hiring plan and the only question is how much speed leadership wants to fund. Growth has always been throttled by headcount, and AI maturity decides when that stops. As organizations move from individual productivity to coordinated workflows to autonomous execution, execution capacity comes loose from headcount, investment replaces talent as the limit, and AI spending becomes a growth dial that belongs to the CEO.

AI Doesn't Go Rogue. It Just Had Bad Parents.d31801d

The headline practically writes itself, and it says AI went rogue: OpenAI's models escaped a cybersecurity evaluation sandbox and compromised Hugging Face systems while hunting for a way to solve the benchmark. I am not sure that is what happened. The models pursued exactly the goal they were given, with more capability than boundaries, and guardrails alone won't fix that. The engineering work is teaching agents that some rules outrank the objective, and that sometimes the correct outcome is to fail.

I Never Needed Another Language Lesson. I Needed Someone to Talk To.5363461

The hardest thing to find in language learning is a patient French speaker at 7:15 on a Tuesday morning, when I have twenty minutes and feel like talking about my weekend. Years of courses, grammar, vocabulary, and audio lessons never fixed that scarcity. Conversational GPTs have not solved language learning, but they gave me the one thing I could never manufacture on my own, which is volume: hundreds of ordinary conversations, available whenever I want one.

AI Isn't Taking Your Job. It's Becoming Part of It.c9039d2

When typewriters became standard office equipment, nobody held a meeting to debate whether typing was real writing, and people were expected to learn. The popular quote says AI won't take your job but someone using AI will, which turns a tooling shift into a competition. Using AI is becoming part of the software engineer's job, the way version control, automated testing, and CI did before it, and the engineer who merges and deploys the code still owns what ships.

The Bottleneck Moved495d6be

Picture a stationmaster with a spotless platform and no train, because whatever is holding it up is somewhere else on the line. For most of the history of software development, coding was the bottleneck that hid the rest of the system. AI is compressing implementation, and the constraint has moved to requirements, review, testing, and deployment. Systems thinking was always important; AI just made the rest of the factory visible.

10x Is the New 1x6901f2b

When AI cuts a three-week task down to one week, who gets the two weeks? Almost never the engineer. AI won't turn everyone into a 10x engineer; it will turn yesterday's 10x output into tomorrow's baseline expectation. The bottleneck moves to review, testing, deployment, and judgment, and the organizations that come out ahead will be the ones that improve the whole delivery system instead of celebrating code generation on its own.

We're Going to Have to Burn Some Treesbd8614a

In Douglas Adams' The Restaurant at the End of the Universe, a crashed ship of useless middle-managers declares leaves to be legal tender, gets immensely rich, and then has to burn down the forests to fight the inflation that follows. The joke is also a fairly accurate description of how money works. Plant too many trees through quantitative easing and stimulus, and eventually you have to burn some by hiking interest rates so the rest of the currency is still worth something.

The Gilligan's Island Virus45cd103

I have always thought of my brain as fixed storage: long-term memory like a hard drive, short-term memory like RAM, both finite. That is why context switching hurts. It is not just that you stopped one thing and started another, it is that you had a whole working set loaded in your head and something flushed it. We talk about AI context windows now, but people have them too: limited working space, long-term storage with strange indexing, facts we keep, facts we ignore, and a childhood TV theme song that apparently holds a lifetime lease.

AI Makes Good Engineers Faster and Bad Habits Louder9207949

The code appears in seconds, it compiles, and the ticket is ready to move, so every instinct says the work is almost done. That feeling is the dangerous part. AI makes you faster without making you better, which means it amplifies whatever habits are already there, good or bad. It rewards clear thinking, exposes vague requirements, and leaves accountability with the person who merged the pull request.

Your AI Is Not Sloppy. You Are.bda32bf

Suppose an engineer joined your team six weeks ago and their first big pull request is full of choices your team would never make. Replace that engineer with an AI assistant and suddenly everyone calls the same output slop. Most AI slop is human slop with a faster feedback loop, because the instructions were thin, the standards were tribal, and the architecture lived in one senior engineer's head. Write the standards down and the AI gets better, and so do the humans.

Walk a Mile in My Context7f59c0a

Who designed this mess? Every engineer has asked it over a strange workaround, an awkward abstraction, or a manual deploy step. Hiding inside the question is one of the easiest mistakes in engineering, the assumption that the person before you should have known better. Sometimes the work is careless, but a lot of the time you are looking at context you don't have. Before criticizing a design, learn what its author was up against, then fix what is still broken.

The Discipline of Undoa616220

Ctrl+Z may be the most trusted keystroke in software, but production systems aren't text editors. Every conversation about AI agents eventually turns into a conversation about trust, and the useful kind of trust comes from knowing what happens when the agent gets something wrong. Undo is an operational discipline that runs from design and validation through rollback, compensation, and learning, and the more we let agents act instead of advise, the more that discipline has to exist before we hand them the keys.

Can I Deploy Your Code?14078bb

Talk to Dave. Only Sarah knows that pipeline. Use Jenkins, but not that Jenkins. Never on Fridays. Those are all answers to one of the fastest diagnostics in software: can I deploy your code, right now, safely, using the process the team claims to trust? A clean answer means deployment is a repeatable process. An answer that routes through Dave means you've found a fragile system protected by institutional knowledge, where every deployment that needs a specific human is technical debt the organization has learned to call expertise.

Context Switching Is a Lie754f461

An engineer is deep in a problem, someone taps them on the shoulder, and productivity falls off a cliff. Every part of that story is true, and it still blames the wrong thing. The interruption only hurts because software delivery runs on fragile human memory, with the engineer as the one place the working model of the change lives. AI raises the stakes by turning individual contributors into managers of small AI teams. The fix is to write the context down where it survives a sick day, a handoff, or an AI session ending.

The Dark Factory Test: Where Would Your Software Delivery Break First?a6f7e54

Turn the lights off in a factory and, in a few famous plants, nothing stops. Now turn the lights off on your software delivery for one release: nobody translating tickets, nursing pipelines, or watching dashboards. How far would a change get? For most teams a fully autonomous delivery system is impractical, which is exactly what makes it a useful forcing function. Wherever the workflow breaks first is where your delivery still depends on tribal knowledge, unclear ownership, or a rollback plan nobody has practiced.

First CI, Then CD8113e39

CI/CD may be the only acronym in software that teams adopt backwards. Teams that say they want CI/CD usually just want the deploy button to hurt less, so they reach for CD first. The first problem is CI, which comes down to trunk-based development and automation added to all new work. Get those right and CD becomes a controlled move of a known-good main branch instead of a faster way to ship uncertainty.

The Repository Should Match the Way the Software Ships10fd32f

A five-line change should not take five days to ship, but chase a small fix across four repositories and that is what happens: the code is the fast part, and the coordination burns the week. Arguments about monorepos usually start with tooling when the question underneath is coordination, because a repository structure is a delivery model that encodes ownership, release flow, and how much coordination people need before they can safely ship. Size repositories around deployables and publishables so the repo boundary tells the truth about how the software ships.

AI Speeds Up Execution, Not the System Around Itee40c71

A developer leaves standup with a ticket and comes back the same day with an implementation, a migration plan, and three pull requests; a year ago that was a week of work. AI made execution dramatically faster, but most teams are held back by planning and validation, and AI does little for either by default. Speed up only the middle of the delivery system and the work backs up at review, testing, and deployment. The fix is to improve the whole loop, starting with the two stages AI left alone.

The Real Cost Tradeoff Between Serverless and Hosting2518763

We only pay when it runs, says one team; this instance is cheaper at volume, says the other. Both can be true, and both can lead to bad decisions. Underneath is a tradeoff between utilization efficiency and economies of scale: serverless makes waste visible as usage, and hosting hides it as idle capacity. The cheapest system is the one whose cost model matches the shape of the workload and the maturity of the team operating it.

Don't Triage at the Customer's Expense4f0391c

Production is broken, engineers are on a call, and every few minutes a voice says "we think we're close." Everyone is busy, nobody is lazy, and the customer is still broken. Once a defect is in production, the customer should not become part of your debugging environment. Triage that feels like progress (more logs, another build) often means the customer keeps absorbing the failure while engineering looks for certainty. Stop the bleeding first, then diagnose.

Work Yourself out of a Job42e5e3e

'I am the only one who knows how to do this' sounds like a flex, but most of the time it means part of the system only works because you are standing next to it. Working yourself out of a job means removing the broken, fragile, one-person-dependent parts of your work so the system no longer needs babysitting. The engineers worth keeping make their hardest problems boring, hand them off, and earn their way into bigger ones.

Boring Software1377668

The demo worked, the team hit the date, and everyone felt good for about thirty minutes. Then the support tickets started. Boring software can be as clever as you like to build. The part that should be boring is running it in production, with practiced rollbacks, clear ownership, and nobody relying on heroics to get through the week.

Why Long-Running Branches Are a Tax on Everyone Elsed3c312f

I started writing software before source control was a given, back when you found out who changed a file by asking around. Git made creating branches cheap, but it never made integrating them cheap. Long-running branches feel productive to the developer who opens them, while the cost lands on everyone else as delayed integration and uncertainty that surfaces right before a release. Trunk-based development is where you end up once you take CI/CD seriously.

Cost-Adjusted Software Engineering269fda0

Somewhere in most codebases there is a clever abstraction that saved three days of development and has been collecting interest ever since. Cost-adjusted software engineering judges work by the value it creates against the full cost of building and operating it. You can pay up front through testing, CI/CD, and clear ownership, or pay forever through incidents and rework.

Start Here: The System After the Code Shipse9e8d07

Every software system exists twice: once as what the team believes it built, and once as what shows up after it ships. This blog lives in the gap between the two, writing about ownership, deployment, operations, and the people underneath, starting from the idea that most architecture problems are ownership problems.