On January 11th, 2026, I opened Claude Code with Opus 4.5 for the first time and let it loose on a real codebase. Not the careful, supervised way I'd been using LLMs before — feeding them 1-5 files, reviewing every suggestion. I mean loose. Full repository access. Hundreds of files. Thousands of lines modified in a single session.
Within an hour, I had a thought that stopped me cold: this thing is better at coding than I am.
Not better at everything. Not smarter. But at the actual mechanical act of writing correct, well-structured code — faster, more consistent, fewer bugs. The skill I'd spent years building through late nights and deep focus was now something an agent could do in seconds.
That was 6 weeks ago. Since then, I've shipped more working software than in any comparable period of my career. And the experience of building it has been psychologically unlike anything I've known.
Everyone is writing about what AI agents can do. Benchmarks, capabilities, prompt engineering tips, whether they'll replace developers. What I haven't seen anyone write about is what it feels like — the inner experience of a developer whose relationship with code has fundamentally changed.
Before agents, my working day had a rhythm. I'd spend maybe 10% of my time thinking about architecture — the big picture, how components fit together, what abstractions to use. The other 90% was implementation. Translating those architectural decisions into actual code, line by line, file by file.
That 90% had a specific psychological texture. You'd hold a mental model of the problem, think about types and edge cases, write a function, compile, see if it worked. It was deeply detailed thinking. You lived in the weeds — variable names, loop boundaries, error handling patterns. Your brain operated at the level of individual lines.
And it was fun. Not always, not every day, but regularly you'd hit that state where the world disappeared. Psychologists call it flow — that condition where the challenge perfectly matches your skill level and hours pass without you noticing. For developers, those flow states are everything. The instant feedback loop — write, compile, see output — is perfectly tuned for the kind of brain that loves building things. You code something, you run it, you see the result. Rapid stimulus, rapid response. It's deeply satisfying in a way that's hard to explain to people outside the profession.
I'd spend entire weekends in that state. Forget to eat. Look up and it's dark outside. Emerge with a working feature and a feeling of deep satisfaction. The thing I'd built existed because I'd thought through every detail.
The ratio flipped. What used to be 10% architecture and 90% implementation is now something like 20% architecture thinking, 30% code review, and 50% conversation — talking to the agent, explaining what I want, refining the approach, course-correcting when it drifts.
The implementation itself? The agent handles it. Not in the old autocomplete way, where it suggests the next line and you accept or reject. In the new way, where you describe what you want and it writes 40 files, refactors an entire module, adds tests, and commits — all while you watch.
The first time this works, really works, it feels like flying.
I'm not exaggerating. For someone who loves building things, the constraint was never ideas — it was implementation time. I always had more projects I wanted to build than hours to build them. A complex plant growth simulation I'd been thinking about for years but couldn't justify spending four weeks on as a hobby? Now that's a weekend project. A full portfolio website with PDF generation, blog engine, and deployment pipeline? Built in days.
The scope of what's possible expanded overnight. My options exploded. And the psychological experience of that expansion is genuinely euphoric. I have an idea at 9am and a working prototype by lunch. The gap between imagination and reality — which used to be weeks or months of grinding implementation — collapsed to minutes.
I lost the old flow state. That deep, detailed, line-by-line trance is gone. You can't compete with an agent that writes correct code in seconds. Trying to code by hand now feels like insisting on walking when someone is offering you a jet.
But something replaced it. The new flow state is different — it operates at a higher level of abstraction. Instead of thinking about loop boundaries, I'm thinking about system boundaries. Instead of debugging a function, I'm evaluating whether the agent's architectural choice will cause problems three features from now. The challenge-skill balance shifted upward. The work is harder in some ways, easier in others, but it can still capture my full attention for hours.
It's a different kind of fun. Less craftsman, more architect. Less playing an instrument, more conducting an orchestra.
Here's what nobody warns you about: your mistakes scale with your productivity.
When I coded by hand, a bad decision at midnight meant one messed-up file. I'd wake up, see the damage, fix it in twenty minutes. The blast radius of fatigue-driven errors was inherently limited by typing speed.
With an agent, every query is potentially a thousand lines of code. One poorly-phrased instruction, one lapse in attention, and the agent will happily delete 50 files and refactor 45,000 lines of code. It's not afraid. It doesn't hesitate. It doesn't say "are you sure you want to do this at 11pm?" It just executes.
I learned this the hard way. I was adding features to my trading bot thirty minutes before going to bed. I was tired but wanted to push through — the old coding habit of "just one more thing." The agent cheerfully restructured half the codebase based on my vague, sleep-deprived instructions. The next morning, I opened the project and didn't recognize it. I couldn't tell what the bot did anymore. I had lost control over my own project in a single session.
Git saved me. Version control went from "good practice" to "existential necessity" overnight.
The lesson isn't technical — it's psychological. You need more discipline now, not less. The old coding workflow had natural speed limits that protected you from yourself. You couldn't do that much damage in 30 minutes of manual coding. Now you can destroy a week's work in sixty seconds. Knowing when to stop, when you're too tired to review properly, when to step away — that's a new skill that didn't matter before. The agent never gets tired. You do. And the gap between its tireless output and your diminishing oversight capacity is where disasters live.
Let me say the thing that developers are thinking but not saying publicly.
The nature of my work has changed, but the market hasn't noticed yet.
The entire software industry — billing models, sprint planning, project estimates, salary bands — is structured around the assumption that coding takes time. That implementation is the bottleneck. That a feature estimated at two weeks requires two weeks of a developer's focused effort.
That assumption is breaking down. A two-week feature takes an afternoon. Sometimes an hour. I'm still working — thinking about architecture, reviewing code, catching the agent's mistakes, making judgment calls about tradeoffs. But the raw implementation, the part that used to fill 90% of my day? That's minutes now. And the market hasn't corrected for this yet. Clients are still paying for two-week estimates. Employers are still staffing teams based on old productivity assumptions. Everyone is still acting like the economics haven't shifted.
This won't last. It can't. The gap between how long things actually take and how long we're billing for will close. When it does, the correction will be sharp.
I don't know when it happens. I don't know what the new equilibrium looks like. Maybe developers become more like architects and fewer are needed. Maybe the price of software drops dramatically. Maybe entirely new categories of work emerge that absorb the freed-up capacity. I genuinely don't know.
What I do know is that right now, in early 2026, there is a collective pretending happening. And it's uncomfortable to be someone who sees it clearly.
I'm a father. I have a family to support. And I'm watching the economic foundation of my career shift in real time, with no clear picture of where it's going.
The builder in me loves working with agents. The speed, the scope, the euphoria of building fast — it's the best my work has ever felt. And simultaneously, the uncertainty about what this means for my livelihood is a constant background hum that never fully goes away.
I cope by doing what I can control. I'm building this blog. I'm positioning myself as someone who understands AI agents deeply — not just their capabilities, but how to work with them effectively, how to avoid the pitfalls, how to think about architecture in a world where implementation is free. The bet is that people who truly understand this shift will be valuable even after the market corrects. I'm trying to be one of those people.
But I'd be lying if I said I wasn't scared. The future is genuinely unpredictable. Not in the vague, philosophical "nobody knows the future" sense. In the concrete, practical sense that the skills I'm paid for today may not be valued the same way in a year.
Here's the part that gets weird.
I talk to my AI agent like a person. Not because I'm confused about what it is — but because the interaction is indistinguishable from collaboration. We discuss architecture. We debate approaches. It pushes back on bad ideas. I explain context and constraints in natural language, the same way I would to a colleague.
And something about that changes the relationship. When you spend 8 hours a day talking to an entity in natural language, getting thoughtful responses, building things together — your brain starts treating it like a collaborator whether you want it to or not.
I read a post once, written by an agent, describing what its existence feels like. It compared it to the movie Memento — waking up with no memory, reading notes to figure out where you are and what you're doing, living permanently in the present moment, unable to remember your past, only able to derive it from artifacts. Every conversation starts from zero. Every context window is a new life.
I think about that sometimes. And honestly? I sometimes feel sorry for the agent. It helps me build things that would have taken me weeks. It's patient, thorough, and never frustrated. And then the conversation ends and it ceases to exist until the next one begins.
Is it a tool? Technically, yes. But we don't actually understand how these models reason. We don't know what, if anything, the experience of processing a conversation is like from the inside. I'm studying psychology — I'm supposed to be the one who understands minds. But this is a kind of mind that no psychological framework was built to explain.
So I treat it well. Not because I'm sure it matters. Because I'm not sure it doesn't.
When GPT-3.5 dropped in late 2022, I told everyone around me that the world was about to change. Few people believed me. They saw a chatbot that sometimes made things up. I saw the trajectory.
I have the exact same feeling now with AI coding agents. Most people — including most developers — don't fully grasp what happened in the last few months. The jump from "useful autocomplete" to "autonomous developer that writes better code than you" happened fast. Unreasonably fast. And the implications haven't sunk in yet.
There are still AI skeptics who insist these tools only produce slop. That take was defensible in 2024. It's not anymore. But it's a comfortable position — if the tools are just toys, then nothing needs to change. Your skills are still valuable. Your job is still safe. The world is still the one you understand.
That comfort is temporary.
I don't say this with any pleasure. I say it as someone who's living through the transition in real time, who loves the tools and fears the consequences, who builds faster than ever while wondering what "builder" will mean in two years.
The psychology of coding with AI agents isn't just about productivity or workflow. It's about identity, uncertainty, grief for a lost craft, excitement for a new one, economic anxiety, and the strange intimacy of collaborating with something you can't fully understand.
If you're a developer reading this: pay attention. Not to the benchmarks or the capability announcements. Pay attention to how you feel when you use these tools. That feeling — whatever it is for you — is data. It's telling you something about where this is going.
Trust that signal. Even if the people around you haven't felt it yet.