Skip to main content

Boilerplate Is Dead

5 min read
BackendApi DevGeneral Swe

Backend

You used to write CRUD. Now you design systems. The bar went up.

Api Dev

Boilerplate was the easy part. API design, versioning, and DX are the hard parts—and they're yours.

Boilerplate Is Dead

TL;DR

  • AI generates CRUD, migrations, config, and repetitive glue code in seconds. The "easy" work is automated.
  • What remains: system design, failure handling, performance, and trade-off decisions. That's the hard stuff.
  • Backend devs who thrive: strong on architecture, debugging, and domain logic. Typing speed is irrelevant.

For years, a chunk of backend work was boilerplate. Set up a project, scaffold endpoints, write migrations, wire up config. Boring but time-consuming. AI does that now. The work that's left is the work that required thinking. That's both good and harder.

What Disappeared (or Shrunk)

  • Scaffolding. New service? AI generates the folder structure, main entry point, and basic routes.
  • CRUD. Create, read, update, delete. AI has this down. You tweak validation and edge cases.
  • Migrations. Schema changes, index creation. AI drafts; you review for locks and rollback.
  • Config wiring. Env vars, feature flags, logging. AI sets it up; you adjust for your infra.
  • Repetitive glue. Serialization, DTOs, basic error handling. Predictable patterns, AI handles them.

What Got Harder (Because It's All That's Left)

  • System design. How do these services talk? What fails when? Where are the bottlenecks?
  • Domain logic. Business rules, edge cases, "what if the payment times out?" AI can implement; it can't discover the rules.
  • Performance. N+1 queries, connection pooling, caching strategy. AI suggests; you measure and tune.
  • Debugging. AI can help trace logs and suggest fixes. Understanding why something broke in production requires context AI doesn't have.
  • Trade-offs. Build vs. buy, consistency vs. availability, tech debt vs. speed. These are human decisions.

The Shift in Daily Work

Before: 60% typing, 40% thinking.
After: 20% typing (or prompting), 80% thinking—architecture, review, debugging, decisions.

Backend devs who only ever did the typing part are at risk. Backend devs who can design systems, reason about failures, and own outcomes are in demand.

How to Adapt

  1. Lean into design. Spend time on RFCs, sequence diagrams, failure modes. That's the work AI can't do.
  2. Own debugging. When prod breaks, you're the one who traces it. AI can suggest; you confirm and fix.
  3. Know your domain. Business rules, compliance, audit trails. AI implements; you specify.
  4. Get comfortable with trade-offs. "We could add a cache here, but it adds inconsistency. Here's the analysis." That's leadership.

New service: create folders, wire config, scaffold routes, write CRUD, migrations. 2-3 days of boilerplate before domain logic.

Click "Backend Scaffolding With AI" to see the difference →

Quick Check

Your last 5 tasks were mostly CRUD and config. What's the best move?

Do This Next

  1. List the last 5 tasks you did. How many were "boilerplate" (scaffolding, CRUD, config) vs. "judgment" (design, debugging, trade-offs)? If it's mostly boilerplate, start volunteering for the judgment work.
  2. Write a one-pager on a system you own: failure modes, scaling limits, upgrade path. That exercise is the work AI can't replace.