Published March 14, 2026
There's a version of developer productivity that gets talked about a lot — velocity, tickets closed, PRs merged. And then there's the version that actually matters: how much of what engineers do is work that requires their judgment, and how much is work that anyone (or any tool) could do if given the right template.
The ratio has always been worse than it should be. Not because companies don't care, but because there's no clean way to separate the two kinds of work. They're tangled together in every sprint, every feature, every codebase.
AI is starting to untangle them.
The common way to frame boilerplate is as a minor annoyance — the stuff you have to write before you can write the interesting stuff. That framing understates the problem.
Boilerplate is time-consuming. It's also error-prone in a particular way: because it feels routine, it gets less attention. Developers write it on autopilot, miss edge cases they'd catch if they were more engaged, and introduce inconsistencies because they're working from memory rather than from spec. The result is a hidden maintenance cost that compounds over time.
More importantly, boilerplate is cognitively exhausting even when it's not intellectually demanding. Context-switching between rote typing and actual problem-solving drains attention. Engineers who spend the morning wiring up service integrations don't bring the same focus to architecture decisions in the afternoon.
When AI handles the scaffolding, the workflow changes structurally. An engineer starts a task by describing what they need — the logic, the constraints, the edge cases that matter — and gets back a working draft. From there, the work becomes review and refinement rather than construction from scratch.
This isn't the same as working from a template. Templates give you a starting point that may or may not fit your context. Good AI generation gives you code that's already adapted to your codebase's conventions, your naming patterns, your existing service interfaces. The delta between the generated code and the finished product is smaller, and the engineer's time is spent on the parts that actually require their knowledge.
None of this removes the need for engineering judgment. If anything, it sharpens the demand for it. When the routine parts are handled, the parts that remain are the ones where the answer isn't obvious, where the right trade-off depends on context that only someone close to the problem can understand.
Architects need to make better decisions faster because they're not buried in implementation. Code reviewers need to focus on what matters because they're not checking boilerplate consistency. Senior engineers can invest more time mentoring because they're not blocked on writing the same patterns they've written dozens of times.
The workflow shifts from writing code to directing code. That's a different skill mix — closer to engineering as a discipline and further from engineering as manual labor.
Changing a workflow isn't just adopting a tool. It requires adjusting how tasks get scoped, how PRs get reviewed, how much trust engineers place in generated output versus manually written code.
Teams that get this right tend to treat AI-generated code the same way they treat any other code: it gets reviewed, it gets tested, it needs to meet the same standards. The difference is that the starting point is further along, so the time to a reviewable state is shorter.
Teams that struggle tend to either over-trust the output (merging without review because it looks fine) or under-trust it (spending as much time verifying as they would have spent writing). Finding the right calibration takes a few sprints, but it's not a long process.
The value of AI in developer workflows isn't that it makes engineers faster at doing the same things. It's that it shifts what engineers spend time on. More business logic. Less scaffolding. More thinking. Less typing.
For engineering teams, that's not a minor improvement. It's a structural change to what the job looks like day to day — and what's possible in a given sprint, quarter, or year.
DeepNest