Shipping Is the Easy Part
Software
Why shipping an internal tool is the easy part, and adoption is the hard, unglamorous work that decides whether the thing you built actually mattered.
I have shipped tools that were, by any technical measure, excellent. Clean code, fast, well documented, solving a real problem. And then I watched them sit there, used by almost no one, slowly going stale until one day I quietly turned them off. The expensive lesson took me years to accept: shipping is the easy part.
TL;DR: Building and deploying a tool is the small part of the work. The larger part, by far, is getting real people to change how they work and actually use it, every week, in their real workflow. That second part is a discipline you can plan for and measure. Most of us skip it and then blame the users.
The graveyard of good tools
Every engineer I respect has a private graveyard of tools that were technically right and practically dead. Mine is not small. When I look back at why each one died, the cause is almost never the code. It is one of three things. Nobody knew the tool existed. Or people knew, but had no reason to change a habit that was working well enough. Or they wanted to use it, tried once, hit friction, and went back to the old way before they ever got fluent.
None of those are engineering failures. They are adoption failures, and I caused all of them by treating the deploy as the finish line. The moment the thing worked in production, I moved on to the next build. I had confused making the tool with making it matter.

Start from the pain, not the thing you built
The habit that changed my results is almost embarrassingly simple. I stopped describing my work by what I built and started describing it by who was hurting and how badly. Not "I built an agent that routes requests across models," but "people were waiting far too long for an answer they needed in the moment, so I built something that gave it back quickly."
The technology belongs in the middle of that sentence, never at the start. Who hurts, how badly as a number, what I built, and whether that number moved. When I open with the pain, two good things happen. I design the right thing, because I am anchored to the outcome and not to my favorite tech. And I can explain it to a person who does not care about my stack, which turns out to be most people whose adoption I need.
It takes more than an engineer to make a tool stick
I used to think of myself as the person who decides how something gets built. That is true, but it is a small slice of the real picture. On anything that ships to actual humans, three jobs have to work together. Someone owns the what and the why, the problem and whether it is worth solving. Someone owns the when and the how it runs, the delivery and the dependencies and the schedule. And someone, me, owns the how it is built, the design and the trade-offs.
The mistake I made for years was operating only in my slice and treating the other two as people who hand me requirements and then get out of the way. The version of me that ships things people use does the opposite. I get in early on the what and the why, because the right technical idea often changes what is worth building at all. And I flag the hard parts of delivery early instead of letting them surprise everyone later. The goal is not to be the smartest person in the room. It is to make the other people look good, because that is what makes them want to build with me again.
Adoption is a change problem, not a software problem
Here is the reframe that finally stuck. Shipping a tool does not equal people using it, and the gap between those two is not a software problem. It is a change-management problem, and change has a known shape. People need to be aware the thing exists and why it is coming. They need to want it, which means it has to solve their pain without threatening them. They need to know how to use it, with real examples, not a wiki nobody reads. They need to be able to use it inside their actual workflow, not a clean demo. And it needs to be reinforced so it sticks, with feedback loops and a few people who champion it from inside the team.
When I started treating a launch like a change instead of a release, the work looked different. I lined up a couple of design partners before I wrote much code. I wrote enablement that showed the tool doing the user's real task. I found one person on each team who would use it first and vouch for it. None of that is glamorous. All of it moves the number that matters.

Measure usage, not launch
"It shipped" is not a metric. It is a date. The metrics that tell me whether my work mattered are about behavior. How many people use it in a normal week. What percentage of the team it was built for has actually adopted it. How much time it gives back, or how many of the old slow requests simply stopped happening. Whether the answers it gives are good enough that people trust it without double checking.
For the AI tools I build, the signals that matter most are behavioral too: how often people fall back to the old way, how often they override what the system proposed, how many requests it quietly failed to resolve. Those are not only adoption numbers. They are the feedback that keeps the model routing and the guardrails honest, so the same usage that proves the tool landed is also what tunes the system underneath it.
I keep a short mental menu of these and I attach real numbers to every claim, even when the honest number is an estimate I label as one. Vague wins are forgettable. "Weekly active usage went from almost nobody to most of the team, and the old request queue shrank to a fraction of what it was" is the kind of result I can stand behind and that other people remember.
The one that taught me this
The lesson did not arrive as a theory. It arrived as a failure. I built an internal tool I was genuinely proud of, announced it once, and assumed quality would carry it. It did not. Weeks later it had a handful of users and most of them were me. Nothing was wrong with the tool. Everything was wrong with how I had rolled it out. There was no enablement, no champion, and it asked people to leave the place they already worked and open one more tab to get an answer. That small tax was enough. The old way was right there, and it was good enough, so they stayed with it.
So I did the unglamorous version. I sat with the people who should have been using it, watched where they stumbled, fixed the friction, wrote a one-page guide built around their real task, and got one enthusiastic early user per group. Same tool, almost no new code. This time it stuck. That contrast is the whole point of this post. The build was never the hard part.
The takeaway
The tool is not the deliverable. The changed behavior is. If I build something excellent and no one's day is different a month later, I did not finish the job, I finished the easy part of it. These days I plan for adoption from the first sketch, I measure usage instead of celebrating launches, and I treat the people who own the why and the delivery as partners I want to make successful. The code still has to be good. It just was never the thing standing between my work and whether it mattered.