The Great Refactoring Nobody Asked For

The Great Refactoring Nobody Asked For

Andrej Karpathy, who has trained some of the most consequential models on earth, said in early 2026 that he feels "behind as a programmer" [2]. Not because he can't use the tools — because the entire profession is being "dramatically refactored" underneath everyone at once, including the people who built the refactoring machine.

That's worth sitting with. If the people closest to the frontier feel behind, the rest of us should stop pretending this is a minor tooling upgrade. Replit CEO Amjad Masad has been blunt about it: we're entering a "post-code era" where AI agents build, test, and deploy autonomously, and the mission for builders shifts from "learn to code" to "outcome creation" [2][4].

That reframing matters more than it sounds. "Learn to code" was a skill with a syllabus. "Outcome creation" is a discipline with no syllabus — it's closer to product management, editorial judgment, and systems thinking mashed together. Faros.ai's 2026 developer survey backs this up directly: teams using Claude Code and Cursor report 10x+ productivity gains, but nearly every respondent flagged the same new constraint — orchestration and review, not generation, is where the real skill now lives [3].

The takeaway: if your team's training still centers on "how to prompt better," you're optimizing the wrong layer. The scarce skill is knowing what to ask for and how to check the answer.

The New Bottleneck: Problem Definition, Not Prompting

HBR's June 2026 analysis of over 12,000 real-world AI use cases found something that should reshape how companies think about AI adoption: the highest-value uses weren't low-level coding tasks at all. They were high-level direction — defining problems precisely enough that an agent could execute against them [6].

This lines up with what we see building orchestration systems. The failure mode isn't "the AI wrote broken code." Models are quite good at writing code that runs. The failure mode is underspecified intent — a founder or PM who says "build me a dashboard that shows engagement" without defining what engagement means, which edge cases matter, or what "done" looks like. The agent will happily build something. It just won't be the right something.

The Medium essay "The Great Refactoring" captures this shift precisely: the bottleneck moves "from how fast we can type to how well we can decide what needs to exist" [2]. That's not a slogan — it's an operational reality showing up in how teams staff projects now. Specification writing has become a genuine craft skill, not a formality you rush through before "the real work" of coding begins.

Practically, this means:

• Spec quality is now the rate-limiting step. A vague brief produces a fast, confident, wrong answer. A precise brief produces a fast, correct one. Same model, same latency, wildly different value.
• Ambiguity is expensive in a way it never used to be. When a human developer hit an ambiguous spec, they'd ask a clarifying question. Agents often don't — they guess, confidently, and ship the guess.
• The people who write the best specs are usually the ones with the deepest domain scars — they've been burned by the edge case before, so they write it into the brief this time.

Verification Is the Real Job Now

Here's the uncomfortable truth: generating software has become nearly free, but trusting software has not gotten any cheaper. If anything, verification has become the majority of the actual work.

This is where RLVR (reinforcement learning from verifiable rewards) and protocols like MCP (Model Context Protocol) enter the picture — not as buzzwords, but as infrastructure for a world where agents need structured ways to check their own outputs against ground truth [2]. The industry is quietly building an entire verification layer because it realized, correctly, that generation without verification is just very fast, very confident guessing.

Human-in-the-loop review isn't a transitional phase before "full autonomy" — for anything with real stakes, it's likely permanent. The HBR research on worker judgment makes the case bluntly: experienced professionals extract huge value from AI precisely because they can tell good output from bad, fast [1]. Juniors without that pattern-matching ability can't perform that check, which means they either rubber-stamp AI output they can't evaluate, or they don't ship at all. Neither is good.

At Up North AI, this shows up constantly in voice AI deployment. A model can generate a conversational flow in seconds. Whether that flow correctly handles an angry customer, a compliance-sensitive question, or a multilingual edge case in Norwegian versus Swedish versus Danish — that's not something you can vibe-check. It requires someone who has actually sat with real customer conversations and knows where things break.

Practical framework for verification-as-a-skill:

1. Define what "correct" means before you generate anything. If you can't articulate the success criteria, you can't verify against it — and neither can the agent.
2. Build test cases from real failure, not hypothetical failure. The edge cases that matter are the ones that have actually happened, not the ones that sound plausible in a planning meeting.
3. Treat agent confidence as noise. Models state wrong answers with the same tone as right ones. Confidence is not a verification signal; it's a language artifact.
4. Compress context ruthlessly. As agentic workflows chain together, context bloat becomes its own failure mode — "context compaction" is becoming a real, teachable skill, not an afterthought [2].

Who Actually Thrives Right Now

The pattern across every piece of 2026 research is consistent, and it's not the pattern most bootcamps or corporate training programs are built around. It's not "the best prompter wins." It's domain depth plus systems thinking wins.

The HBR finding bears repeating because it's the single most important data point in this whole shift: workers with deep experience get outsized gains from AI, while junior employees without that grounding often can't evaluate whether the output is good [1]. This isn't an argument against hiring juniors — it's an argument that the on-ramp for judgment needs to be rebuilt from scratch, because the old on-ramp (write lots of code, get code-reviewed, learn from mistakes over years) assumed code-writing was the training ground. If code-writing is now delegated to agents, where does a junior actually build the pattern-recognition that senior judgment depends on?

That's a real, unsolved problem. Nordic tech culture — with its emphasis on apprenticeship, flat hierarchies, and direct feedback — may actually have an advantage here. A junior engineer paired tightly with a senior who narrates why they're rejecting an agent's output, not just that they're rejecting it, transfers judgment faster than a junior left alone with a chatbot and a vague task. The skill has to be taught deliberately now, because it's no longer a side effect of grinding through code review.

Developer reports through 2026 reinforce this: agentic workflows have let non-coders ship full applications end-to-end, but the people building genuinely durable, secure, well-architected systems are the ones who already understood architecture before the agents arrived [4]. The tool amplifies existing judgment. It does not manufacture judgment that wasn't there.

The portfolio is changing too. Faros.ai and multiple 2026 hiring discussions note that strong builder portfolios increasingly showcase orchestration pipelines, verification frameworks, and agent-coordination design — not raw GitHub repos of hand-written code [3]. If you're hiring or building a personal brand as a technologist in 2026, "I wrote 50,000 lines of code" is a weaker signal than "I designed a system where five agents coordinate to ship a verified feature safely."

What This Means for Builders and Founders

If you're running a team or a company right now, here's the practical shift to make, stated plainly:

Stop hiring and training for code output. Start hiring and training for decomposition, specification, and verification. These are teachable — but they require deliberate practice, not osmosis. Build review rituals where senior people explain their reasoning out loud, not just their conclusions.

Rewrite your onboarding. If junior hires used to learn judgment by writing code and getting corrected, and that loop is gone, you need a replacement loop. Pair juniors on verification tasks specifically — have them evaluate AI output against a rubric a senior person built, then compare notes. That's the new code review.

Audit where your team's time actually goes. If your engineers are still spending most of their time typing rather than specifying and checking, you're leaving the 10x gains other teams are already capturing on the table [3].

Treat specs as a product, not paperwork. The teams getting the most out of agentic tools in 2026 are the ones who invest real time in writing precise briefs — because a vague spec plus a fast agent just produces a wrong answer, quickly.

The Bigger Shift

Here's the thing that's easy to miss in all the noise about coding agents and 10x productivity claims: this was never really about code. Code was always just the physical manifestation of a decision someone made. AI has made the manifestation nearly instantaneous and nearly free. It has done nothing to make the decision easier.

If anything, decisions have gotten harder, because the cost of acting on a bad decision has dropped along with the cost of acting on a good one. A wrong architecture used to take weeks to build and fail — giving you time to notice something was off. Now it can be built, deployed, and causing damage in an afternoon. Speed without judgment isn't progress. It's just faster mistakes.

That's the real meaning behind "code is free, judgment isn't." It's not a clever tagline — it's a description of where economic value is actually sitting right now. The organizations and individuals who win this decade won't be the ones who generate the most code. They'll be the ones who can look at a pile of AI-generated possibilities and know, with earned confidence, which one is actually right.

We build voice AI, orchestration platforms, and data tools at Up North AI because we believe this is the real frontier — not making generation faster, but making judgment scalable, teachable, and verifiable. The tools got smarter. The job now is making sure we do too.

Sources

1. https://hbr.org/2026/02/how-do-workers-develop-good-judgment-in-the-ai-era
2. https://medium.com/@nishantsoni.us/the-great-refactoring-a-guide-to-the-post-code-era-948b0dc21eb8
3. https://www.faros.ai/blog/best-ai-coding-agents-2026
4. https://www.linkedin.com/posts/hypertrail_the-future-of-software-beyond-the-code-activity-7434628077248212992-RKaR
5. https://www.amazon.com.au/DISPOSABLE-CODEBASE-Engineering-Post-Code-Revolution-ebook/dp/B0GQPZ69HL
6. https://hbr.org/2026/06/how-people-are-really-using-ai-in-2026
7. https://www.library.hbs.edu/working-knowledge/ai-trends-for-2026-building-change-fitness-and-balancing-trade-offs