AI writes code better than me

A few weeks ago, Andrej Karpathy posted something that many of us quietly felt but didn’t want to say out loud: he’s never felt this far behind as a programmer. Not because he forgot how to code, but because the whole profession is being refactored under our feet.

His point wasn’t "AI is coming." It was "AI is already here, and the new skill is knowing how to operate this weird, powerful abstraction layer: agents, prompts, context, memory, tools, workflows, IDE integrations, and the mental model to manage something stochastic, fallible, and constantly changing."

This statement is so powerful that I can easily say:

AI writes code better than me, but it is still very stupid in regards architecture.

A big shift

A big shift is happening in software development. AI already writes code better and faster than many developers, but it still does not understand the bigger picture. It struggles with architecture, trade-offs, and long-term decisions. Today, programming is less about writing every line by hand and more about deciding what to build and how everything fits together. If you are new to the industry, this shift is already your norm. You enter a world where AI is part of the process from day one, and adapting to it comes naturally rather than feeling like a loss.

The mental problem

For experienced developers, the hardest part is not technical, it is mental. For years, satisfaction came from writing code by hand and seeing it work. That moment of “it runs” gave a real dopamine hit. Now, instead of coding, you often write prompts and guide AI. This feels slower, less creative, and much more boring. You lose the feeling of direct control and craftsmanship, even if the results are better. Many senior programmers struggle not because they cannot use AI, but because it takes away the kind of satisfaction they built their careers on.

Transformation time

For years, we treated software development like a typing competition:

• Who ships faster
• Who knows more frameworks
• Who can hold more complexity in their head

But the bottleneck is moving.

When an agent can implement features, refactor modules, and write tests in minutes, manual coding stops being the constraint. The constraint becomes:

• quality of decisions
• architecture and decomposition
• review, verification, and risk management
• product taste and user value

In other words, software engineering shifts toward engineering and product thinking, not just writing code.

This is why I think architects are about to be dramatically more valuable than the market currently prices them. Not the "draw boxes" kind of architect, but real ones: people who can define constraints, pick trade-offs, design evolvable systems, and translate business goals into technical reality.

The risk

If coding is cheap, you can create chaos faster than ever.

So we need a new discipline: how to build software with AI without drowning in AI-generated debt.

Many of us try to use AI in following AI

I mainly work with the following flow:

What does my workflow look like?

Here’s a model that works surprisingly well.

Shared language and rules

Every repository contains a guidelines_language.md file that defines:

• formatting and style
• project structure
• coding best practices

This creates a stable baseline.

Architecture first

Before touching implementation, I define:

• architectural style (modular monolith, hexagonal, DDD, clean architecture)
• API conventions, error handling, logging, telemetry
• security assumptions (authentication, authorization, secrets, threat model)

This is then turned into a reusable context pack or skill file that I attach to every agent prompt.

Slice the elephant

• define domain boundaries (what’s in and what’s out)
• list data contracts and key flows
• identify invariants (what must never happen)
• break work into thin vertical slices
• add acceptance criteria for each slice

Delegate to the AI agent

For each slice, I define:

• goal (what user value changes)
• constraints (principles and architectural rules)
• inputs and outputs (APIs, schemas, events)
• non-goals (what not to touch)
• definition of done (tests, docs, edge cases)

Review and verify

After generation, I review the code using a different AI or a different agent.

Then I run static analysis because you shouldn’t trust vibes:

• complexity creep
• duplication
• vulnerability patterns
• dead code
• weak error handling
• suspicious constructs that "seem fine"

Tools like Sonar, linters, type checkers, and security scanners are non-negotiable.

The paradigm shift

Coding is no longer the bottleneck.

This is the emotionally hard part for many engineers, including myself:

Coding skills are becoming a commodity.

Code is getting cheap and abundant, just like compute, storage, and distribution before it.

So what becomes scarce?

• good judgment
• systems thinking
• product sense
• prioritization
• ability to reduce ambiguity
• taste (what to build and what to ignore)
• ability to design constraints and trade-offs
• ability to verify and operate systems reliably

And that’s why the role changes.

The engineer becomes a generalist. Not someone who knows everything deeply, but someone who:

• navigates domains quickly
• builds strong mental models
• asks the right questions
• connects business intent to technical reality
• orchestrates tools, agents, and humans into outcomes

AI can generate a thousand lines of code in seconds.
But it still can’t decide:

• whether the system should be event-driven
• how to model the domain
• where boundaries belong
• what the long-term cost of a shortcut will be
• which trade-off is acceptable for your business

That’s the human role.

And it’s about to be rewarded.