I'm starting to think about my work differently.
Tonight before I left the office, I outlined three objectives for a side project. Not detailed specs. Not tickets with acceptance criteria. Just clear statements of what I wanted to happen: "Refactor the API endpoints to use a new pattern. Add tests for the error handling. Update the documentation."
Then I logged into Claude Code, pasted the objectives, added some context about the codebase structure, and hit go.
The reason I'm writing this is because I left it running. I went home. Had dinner. Watched something with my wife. Got some sleep. And when I checked my laptop this morning, the work was done.
Not perfect. Not production-ready without review. But done. All three objectives, completed.
There's something fundamentally different about that workflow compared to everything I've done for two decades.
In traditional development — and I include AI-assisted development-as-I-was-doing-it — you're at the keyboard. You're directing. You're deciding. You're iterating in real-time. It's a conversation between you and the code (or between you and the AI writing code).
This is different. This is: set the direction, give the constraints, then let the system work.
It's closer to delegation than to collaboration.
I could give it a task and trust that it would attempt it. It would run into edge cases and errors and missing context. It would iterate on its own. It would test its work. It would back up and try a different approach if something wasn't working. And it would keep going until either it succeeded or it ran into a hard constraint.
The amount of human review and iteration needed is real. I'm not putting untested code into production. But the waiting time has changed. The dependency has changed.
Before, I was the bottleneck. I could only go as fast as I could think and type and debug.
Now, the bottleneck is the clarity of my instructions and my willingness to review the output.
I haven't fully absorbed what that means yet. It changes the economics of side projects. It changes the pace at which I can iterate. It changes what's feasible for one person to build.
But I'm starting to get the sense that it also changes the kind of thinking I need to do. Less implementation thinking. More design thinking. More: "What problem are we solving?" and "What constraints matter?" and less "What's the next line of code?"
It's early. I'm still figuring out when this mode of work is appropriate and when I need to be at the keyboard. But tonight, writing three objectives and letting Claude Code work through the night felt like the future of solo development.
It's not magic. It's not even fully autonomous yet. But it's a meaningful step away from "I type, code appears" toward "I plan, code emerges."
That shift matters.