I had a conversation with a client last week where I was, in the space of twenty minutes: the product person deciding what we should build next, the architect deciding how it should fit with the existing system, the engineer implementing it, and the QA person verifying it worked.
Not sequentially. Not in separate meetings with separate hats. All at once, in one conversation, with agents running in the background.
This is the job now. And I'm not sure we've reckoned with what that means.
A year ago I wrote about the rise of the product engineer — the person who cares about what gets built, not just how. And about the death of the developer — the middle layer of pure implementation being automated away, leaving architects, product people, and QA.
What I didn't anticipate was how quickly those three remaining roles would collapse into one person.
Not for everyone. Not in every context. But for a certain kind of experienced engineer with AI tooling, the boundaries between product thinking, system design, and implementation have dissolved. Not blurred — dissolved.
I decide what to build. I decide how it should work. I build it. I verify it. I ship it. I watch what happens. I adjust.
The feedback loop that used to take a team of eight people and three weeks now takes me and an afternoon.
Here's what yesterday looked like.
A client described a problem. Not a feature request — a problem. Users were dropping off at a specific point in their workflow. We talked about why. I asked questions a product manager would ask. What are they trying to do? Where does it get confusing? What would "fixed" look like?
Then, while still on the call, I started thinking about the architecture. Not in a whiteboard way — in a "I know this codebase and I know where this change needs to live" way. The agent had the repo open. I could see the relevant files. I was already forming the shape of the solution.
After the call, I described the change to the agent. It scaffolded the implementation. I reviewed it, adjusted the parts that didn't account for an edge case I knew about from three months ago, wrote a test for the scenario the client described, and deployed it.
Two hours. Problem to production.
That's not a flex. That's just what vertical integration looks like when the tools are good enough.
No handoffs. No "let me check with the team." No requirements document that gets misinterpreted. No architecture review where someone who hasn't touched the code in six months questions your approach. No waiting for a sprint to start.
The signal stays clean. The client says "this is the problem," and the person who heard them describe it is the same person who fixes it. Nothing gets lost in translation because there's no translation.
Decisions are faster because the person making the product decision, the architecture decision, and the implementation decision is the same person. They don't need to be convinced. They don't need to schedule a meeting. They just need to think clearly.
And the AI handles the part that used to be the bottleneck: the typing. The boilerplate. The "I know exactly what this should look like but it'll take me four hours to write it." Now it takes minutes, and I spend my time on the parts that actually require judgment.
Here's what nobody talks about: being the entire stack is exhausting in ways that don't show up as hours worked.
When you're the product person, the architect, and the engineer, there's nobody to disagree with you. Nobody to say "have you considered..." Nobody to catch the assumption you didn't know you were making.
I miss that.
I miss the architect who'd look at my design and say "this won't scale the way you think it will." I miss the product person who'd push back and say "users don't actually want that, they want this." I miss the QA person who'd find the edge case I was too close to the code to see.
AI can do some of this. You can ask it to critique your architecture, poke holes in your product thinking, find edge cases in your implementation. And it's decent at it. But it's not the same as a person who has their own context, their own experience, their own stubbornness about things they've seen go wrong before.
The AI agrees with you too easily. It challenges you when asked, but it doesn't have the conviction of someone who's been burned by the same mistake you're about to make.
There's a social cost too.
Software used to be collaborative in a way that was sometimes frustrating and sometimes wonderful. The back-and-forth. The whiteboard arguments. The moment when someone else's idea clicks with yours and you build something neither of you would have built alone.
When you're the entire stack, that goes away. You're not collaborating. You're deciding. All day. Every decision. With an AI that's helpful but not opinionated.
Some days this feels like freedom. Other days it feels like solitary confinement with a very capable cellmate.
Here's the honest part: is the work better?
Sometimes. When the problem is well-defined and I have deep context, the vertical integration produces better results faster than any team I've worked on. No information loss. No misalignment. No politics.
But sometimes it's worse. Because I have blind spots, and there's nobody to cover them. Because I get attached to my first idea, and there's nobody to kill it. Because I'm tired, and there's nobody to notice.
A team has redundancy. Not just in capacity — in perspective. When one person is the entire stack, there's no redundancy at all. If I'm wrong, the whole thing is wrong. And I won't always know I'm wrong, because the person who would have caught it is me.
The new generation of AI agents makes this both better and worse.
Better because the agents can genuinely run in parallel. I can have one agent investigating a bug while I'm thinking about product direction for a different feature. The throughput is real.
Worse because the agents need direction. Good direction. The kind of direction that requires you to be the architect, the product person, and the engineer simultaneously. You can't just say "fix the bug" — you need to know which fix is architecturally sound, which one aligns with the product direction, and which one won't create three new bugs.
The agents amplify whatever you point them at. If your product thinking is sharp and your architecture is clean, they amplify good work. If you're confused or tired or making assumptions, they amplify that too. Faster than a team would, because a team would push back. The agents just execute.
I don't think "one person does everything forever" is the answer. I think it's a phase. A powerful, productive, slightly dangerous phase.
The sustainable version probably looks like this: one person who can do the entire stack, working with other people who can also do the entire stack, each bringing different blind spots and different experience. Not a traditional team with role boundaries. A group of vertically integrated people who challenge each other.
Small. Senior. Opinionated. Each one capable of the whole job, but better because they're not doing it alone.
That's what I'm building towards. Not because being the entire stack doesn't work — it does, remarkably well. But because the best version of this isn't a solo act. It's a small band where everyone can play every instrument, and the music is better for it.
For now, though, it's mostly me. Me and the agents. Deciding what to build, designing how it works, building it, checking it, shipping it.
It's the most productive I've ever been. It's also the most exposed I've ever been. Every success is mine. Every mistake is mine. There's nowhere to hide and nobody to blame.
I wrote earlier that the death of the developer left three jobs: architect, product person, QA. What I'm learning is that for some of us, those three jobs are now one job.
And the person doing it needs to be honest about what they're good at, what they're bad at, and where the AI is papering over gaps that a real colleague would have caught.
That honesty is the hard part. Harder than the architecture. Harder than the product thinking. Harder than the code.
But if you can manage it — if you can be the entire stack and still know where you're weak — the work you produce is something that didn't used to be possible.
One person. The whole thing. Shipped.
I just try to remember to ask myself the question nobody else is asking: "What am I missing?"
Because the answer is never "nothing."