Published on

AI is industrializing code, so in 2026 I'm betting on fundamentals

AI is industrializing code, so in 2026 I'm betting on fundamentals
Authors
On this page

Everyone asks whether AI will replace developers. I care more about what happens to a craft when production gets cheap.

I use coding agents every day. The framing that's held up best for me is industrialization: more code, faster, and a bigger premium on the people who understand the whole system.

TL;DR: my 2026 strategy

AreaOld approachNew approach
CodingWrite everything manuallyAI for boilerplate, manual for architecture
LearningSpecialize deeply in one stackGeneralize broadly + depth where it matters
ToolsOne IDE, one languageClaude Code + Cursor + multiple languages
Value propLines of code writtenSystem understanding + judgment calls

The rest of this post is why I think the shift matters, and what I'm doing about it.

AI: from skepticism to cautious realism

One shift I've noticed: people are moving from pessimism to cautious realism about AI-generated code. This isn't another hype piece. I have concrete reasons for the view.

DHH has said publicly that he still loves writing code by hand, but that modern AI coding tools have gone from toys to genuinely useful. He's built successful software products, so that shift carries weight.

Linus Torvalds is even more telling. The creator of Linux is famously skeptical and allergic to marketing nonsense, and he's acknowledged that AI models are now genuinely useful for development tasks. When someone with his decades of experience, and no financial stake in AI, adjusts his stance, it's worth paying attention.

Industrial software: how delivery changed

"Industrial software" is the most useful lens I've found for what's happening now. The core idea: AI-generated code is the industrialization of software development.

Think of a handmade painting, where the artist spent months on every brushstroke, next to a printed poster. The poster isn't art, but it scales infinitely easier.

Or compare a mechanical watch full of complications, costing thousands of dollars, with a quartz watch that costs a few dollars and keeps better time. One is craftsmanship for its own sake. The other is industrial efficiency.

Cartoon of a robot with a screwdriver standing between an ornate mechanical watch under glass and a plain round quartz clock.

Software is drifting toward the quartz watch, whether we like it or not. For most of software's history, complexity was built in. You needed time, skill and experience. Code was expensive because people were expensive, and people were the bottleneck.

AI breaks that. Production gets cheaper, faster, and more and more disconnected from human expertise.

Once production detaches from skill, you don't get better code. You get more code. Notice that articles hyping AI focus on quantity, not quality, because nobody cares about quality in an industrial revolution.

When an industry industrializes, the first effect is almost never better craftsmanship or long-term reliability. It's a sharp jump in volume. Barriers to production fall, labor partly drops out of the equation, specialized skills stop being the main constraint, and output grows faster than the ecosystem around it can absorb.

Once production is cheap enough, the system optimizes for quantity over quality. You can see the pattern from publishing to food production. Nobody set out with bad intentions, but economic pressure keeps bending mass production toward high volume, low durability and low individual value.

People argue that AI isn't good enough to produce reliable code. They might be right. It doesn't matter, because the rules of the game have changed. Low-quality, mass-produced software will often be good enough to win, just as a cheap plastic toy is more profitable for the manufacturer than a handcrafted wooden one that takes weeks to make.

The 90% iceberg: what AI cannot replace

Adapting to coding agents is the easy 10%. What separates a valuable software developer from a "vibe coder button pusher" is the other 90%: the boring stuff that doesn't get likes, views or VC money.

That means knowledge and experience. Every industrialized process still has chokepoints where automation is limited and humans stay the decisive factor. Factories still need engineers. Mass food production still needs nutritionists, safety regulators and people who understand supply chains.

Even the most automated systems rely on a small group of people who understand how everything fits together, where it breaks, and what the second and third-order effects look like when something goes wrong.

Software is no different. AI can generate code well, but it doesn't understand it beyond the probability of the next token. That limitation matters.

Diagram of the software development iceberg showing AI boilerplate at the tip and foundational system skills below the surface.

The generalist imperative

My priority for 2026: keep learning, master the basics, and become a true generalist. There's been plenty of talk about "full stack fatigue", but I think this is where the most value gets created.

"Specialization is for insects" fits here. A developer who understands several layers of the stack will be worth more than one who only knows a single framework deeply.

This year I'll keep writing up what I learn: new languages, frameworks and software concepts. More runtime internals, more databases, more operating systems, more boring fundamentals that compound over time. Learning new things is fun. But understanding how the layers fit together is the only reliable way to keep moving forward.

Reflections

I want to stay balanced here: neither pure hype nor pure doom. The industrial framing is a lens, not a prophecy.

And there are real counterpoints. Does industrialization necessarily mean lower quality? Open-source peer review suggests quality can scale. Is the "90% iceberg" immune to AI? The line between "generating code" and "understanding systems" gets thinner every year. And nobody talks enough about what this does to developers.

My current setup

Here's what I'm using this year:

AI coding tools:

  • Claude Code: my main agent for complex refactoring and multi-file changes
  • Cursor: my daily driver IDE, with inline completions
  • GPT-4o-mini via API: the cheap option for repetitive tasks (~$3/month)

What I let AI do:

  • Boilerplate (CRUD endpoints, test scaffolding, config files)
  • Documentation and comments
  • Converting between formats (JSON ↔ YAML, SQL ↔ ORM)
  • First-pass code reviews

What I do manually:

  • Architecture decisions
  • Security-critical code
  • Performance optimization
  • Debugging production issues
  • Code that touches money or user data

Monthly cost: Claude Pro and Cursor Pro at $20 each, plus API usage

Comparison diagram showing tasks delegated to AI coding tools versus critical tasks retained for manual development.

Skills I'm doubling down on

These are the "90% iceberg" skills that compound over time:

SkillWhy it matters
System designAI can't architect; it can only implement
Debugging productionUnderstanding distributed systems, logs, traces
Database internalsQuery optimization, indexing, replication
NetworkingDNS, TLS, load balancing, CDNs
SecurityThreat modeling, auth flows, encryption
Reading codeMost work is understanding, not writing

My 2026 learning list:

  1. Deep dive into PostgreSQL internals
  2. Learn Rust (systems thinking, memory model)
  3. Container orchestration beyond kubectl apply
  4. Observability stack (OpenTelemetry, Grafana, traces)

Where generalist engineering wins

AI coding tools make boilerplate cheap. What stays scarce is judgment: knowing what happens when a database connection pool runs dry, how to debug an upstream 502 at 2 AM, and where to put idempotency checks so retries don't charge a customer twice.

My takeaway: let coding agents clear the mechanical typing out of the way. Spend the time you save on the parts that break under load: query planners, network timeouts, failure isolation and data integrity.

Stay broad. Understand the whole system, and learn to build, maintain and evolve software that works, not just generate code.


Resources

Frequently asked questions

Will AI replace software developers?
My view is no. AI industrializes code production, so you get more code, not better code. Developers who understand whole systems, including design, debugging, databases, networking and security, stay the decisive factor.
What does industrial software mean?
It is the idea that AI-generated code does for software what factories did for goods: production gets cheap and fast, output volume rises, and low-cost software that is merely good enough often wins.
What should developers focus on in 2026?
Become a generalist who uses coding agents for boilerplate while going deeper on system design, production debugging, database internals, networking and security.