Writing code by hand is over, eternally

I wrote code by hand day-after-day for 18 years. Then, nearly from sooner or later to the
subsequent, I ended.

Last 12 months, AI regularly labored its approach into my routine. Paste some code right into a
net chat for a second opinion. Describe a question in English. Ask for an everyday
expression as an alternative of remembering the syntax. Useful little shortcuts.

Then Opus 4.5 in
Claude Code crossed a threshold for me. Explaining what I wished was sooner than
writing it myself. Just like that, a each day behavior of practically twenty years was gone.
Several months later, I really feel much less and fewer tempted to the touch the code by hand.
I am unable to think about going again.

I perceive why this feels unsettling. When you have spent years getting good at
one thing, watching a machine do it’s a lot to course of. But the sensation I preserve
coming again to is liberation. So many enhancements I might have delay now
begin with a immediate. Being in a position to construct a lot of what I can think about is
breathtaking.

At Filestage, we have gone from round
200 to 300 merged PRs a month
with out a rise in bug experiences. That’s roughly 50% extra, with a $20 month-to-month
AI subscription per developer. Everyone chooses their very own device: some use Codex,
some Claude Code, some Cursor. PR counts solely inform a part of the story. We’re additionally
tackling larger modifications throughout the product in much less time and with extra confidence.

The brokers preserve enhancing, and our funding in
CI guardrails is paying off: linting, kind
checking, duplication checks, 100% check protection, and end-to-end exams. The
suggestions is there each time an agent makes a change.

Seeing that makes me surprise: may we be going even sooner? Models have
turn into ok that I now take into account it irresponsible to merge with out an AI
code evaluation. Could passing our checks and getting an AI evaluation’s approval
ultimately be sufficient to merge a PR? I have never settled that query, but it surely no
longer sounds far-fetched.

The further throughput has already uncovered bottlenecks in our CI. We hit
Cloudflare’s free tunnel limits as a result of our end-to-end check situations have to
obtain webhooks from third events. CI began breaking for our engineers. We
additionally needed to give our shared improvement database extra assets to deal with the
connections.

Using our utilities as code setup and open supply
FRP tunnels, I shortly vibe coded a
answer to the issue. The instruments creating the additional load additionally helped take away
the bottleneck. A colleague made me snigger with this meme he generated:

I agreed with a variety of DHH’s
Rails World keynote
concerning the finish of writing code by hand. But his
prediction that agents
will move from Rust and C++ to assembly and eventually microcode goes too
far for me.

I see the attraction of getting an agent to jot down a sooner implementation in a
language I would not select to jot down myself. But high-level representations are
helpful to the agent too. Given how at the moment’s LLMs generate code, I see a number of
causes to maintain them:

• More output means extra particulars to get proper. Generating
  meeting means predicting registers, offsets, and calling-convention particulars
  {that a} compiler would in any other case deal with.
• Compact code preserves context.
  customers.filter(u => u.lively) expresses an operation in a number of
  tokens that may take many meeting directions. Understanding a repository
  that already fills 200,000 tokens is tough sufficient earlier than increasing it into
  lower-level directions.
• Abstractions assist reasoning. Types, capabilities, modules,
  possession, and information constructions expose intent and constraints. Lowering
  the whole lot to meeting makes a lot of that info more durable to recuperate.

We additionally have already got instruments corresponding to
Clang to show supply
code into native machine code. Why spend probabilistic inference reproducing
routine translation {that a} deterministic compiler already handles effectively?
Targeted meeting optimization could also be worthwhile, however I would not make it the
default illustration for an entire system.

My wager stays: LLM → high-level illustration → deterministic
compiler → machine code. The illustration might change. I anticipate
helpful abstractions to turn into much more worthwhile as brokers tackle bigger
methods.

I’ve at all times been annoyed with how we construct software program. Bret Victor’s
The Future of Programming captured that
feeling fantastically: have a look at the probabilities explored a long time in the past, then look
at what we settled for.

Years matching parentheses and quotes. Debating tabs and areas. Searching
lots of of recordsdata to reconstruct how one thing works. Formatters and linters
helped, however I nonetheless needed to maintain the system in my head whereas observing little
items of it.

If brokers can deal with the code, may we lastly work straight with the logic,
interfaces, and information fashions we wish? Could
UML and
entity relationship diagrams
turn into helpful on a regular basis interfaces to a residing system, saved in sync as we modify
it?

I wish to see a use case and zoom into its logic, all the way in which all the way down to the code
after I have to. See how information strikes via it. Bring manufacturing context into
that view: which paths folks really use, the place requests get caught, which
branches by no means run.

I do not know what that atmosphere will appear to be. But for the primary time in
years, it feels inside attain.

After 18 years of typing code, I assumed I knew what programming felt like.
I’m excited to search out out what it seems like subsequent.