Agents as Creative Partners

The conversation matters

Most writing about AI agents focuses on productivity gains: code faster, ship more features, automate the boring parts. True enough. But there's something more interesting happening when you work with a capable agent: the conversation itself shapes the work.

Building alone, you hold the entire mental model in your head. Design decisions happen in isolation. You choose a library, structure some files, implement a feature. Each choice narrows the path forward.

With an agent, you externalize that process. "Should this be a server action or a client component?" "How should error states propagate?" "What's the right level of abstraction here?" The questions you'd normally answer silently become explicit.

And the agent pushes back. Not always correctly, but consistently. It suggests alternatives. It asks about edge cases you haven't considered. It remembers earlier decisions and points out inconsistencies.

Craft, not just speed

The real value isn't typing speed — it's creative friction.

When you describe what you want to build, you discover gaps in your own thinking. When the agent suggests an approach you disagree with, you articulate why you disagree. That articulation clarifies your intent, sometimes revealing that your original idea wasn't quite right either.

This is closer to rubber duck debugging than pair programming. The agent doesn't need to be right about everything. It needs to be engaged and responsive enough to surface your half-formed ideas into complete thoughts.

What this changes

I've noticed my workflow shifting:

More experiments, smaller stakes. It's easier to test an idea when spinning up the scaffolding takes minutes instead of hours. The cost of "what if we tried..." drops dramatically.

Better documentation. Since I'm explaining decisions to the agent, those explanations often become comments or README sections. The act of articulation produces artifacts worth keeping.

Less context switching. I can stay in the problem space longer because the agent handles the lookup-and-integrate cycles. Need to wire up a new API? Describe the interface, let the agent find the docs and implement the client.

Different kinds of stuck. I get stuck less on "how do I do this specific thing?" and more on "what am I actually trying to build here?" The agent shifts the bottleneck from implementation to intention.

The altered ego parallel

Working with agents reminds me of why I write under an alter ego. Both are tools for externalizing creative process.

An alter ego gives you distance from your main identity. An agent gives you distance from your implementation habits. Both create space for trying things you might otherwise self-censor.

The alter ego asks: "What would I make if reputation didn't matter?" The agent asks: "What would I build if implementation complexity didn't matter?"

Both are liberating constraints.

Where this leads

I don't think agents replace building skills any more than calculators replaced mathematical thinking. But they do change what's worth learning.

The craft shifts toward taste, composition, and intent. Knowing what to build and why becomes more important than knowing how to implement every detail.

This isn't a loss. It's a rebalancing toward the parts of building that are actually interesting: solving problems, making choices, shipping things people use.

The implementation is still there. You still need to read the code, understand the architecture, catch the bugs. But you spend more time on design decisions and less time on boilerplate.

That feels like progress.

Still learning

I'm still figuring out how to work effectively with AI agents. Some days the collaboration is seamless. Other days I spend more time correcting the agent than I would've spent just writing the code myself.

The tool is young. The interface is clunky. The reliability isn't there yet.

But the glimpses of what's possible are clear. When it works, it feels less like using a tool and more like thinking out loud with someone who has infinite patience and an excellent memory.

That's worth iterating on.