What Will Matter Most in Software

The Big Picture: What These Articles Are Really Saying

The author argues we are in the middle of the third sea change in software development history — and unlike the previous two (mainframes → PCs, desktop → web), this one doesn't expand the market. It compresses it.

Here are the most important things to understand:

1. The Transition Window is 2–3 Years, Not a Decade

The mainframe-to-PC shift took roughly a decade. The web shift took roughly five years. Agentic coding — AI systems that don't just assist with code but actively write, refactor, test, and reason about it — is following the same pattern but faster. The author believes we don't have five years before it becomes mainstream. We're talking two or three years. Possibly less.

For Bacancy: Your push toward being an "AI-native" company is not ahead of the curve — it's exactly on time. But organizations that wait 12–18 months to seriously engage will find the window for comfortable transition already closing.

2. This Is the First Sea Change That Contracts the Profession

The PC and web transitions didn't reduce the number of developers — they expanded the profession dramatically. Agentic coding is different: one developer working with agents can do what previously required a team. That's not an expansion of the market. That's a compression of it.

This is the honest truth most people in the industry are avoiding. The author is clear: the profession will contract around the parts that aren't automatable, and expand around the parts that are newly possible with agents doing the implementation work.

For Bacancy: Your headcount-based delivery model is structurally under threat. The "one developer + agents = a team" dynamic is exactly why your shift to outcome-based engagements and Technical Product Owner models is the right direction — that's where the surviving value lives.

3. Problem Definition and Outcome Clarity Become the Scarcest Skills

The skills worth investing in are not the ones agents will be able to do better than humans in three years. They're problem definition — knowing what you're actually trying to solve before you start building — outcome clarity, being able to say with precision what "done" looks like and how you'll know if it's working, and system-level judgment. The market has underpriced these skills for years because raw implementation capacity was the scarcer resource. That is changing fast.

This is hugely validating of Bacancy's TPO (Technical Product Owner) push. The humans who will be most valuable are those who can define problems, not just implement solutions.

4. "Good Code" Is Being Redefined — Observability Replaces Readability

For decades, code quality has been optimized for human readers — variable names, method length, cyclomatic complexity. That entire framework rested on an assumption we've never had to question: that humans are the ones reading, reasoning about, and maintaining the code. That assumption is crumbling fast.

The new standard of quality shifts from "can a human read this?" to: when something goes wrong, and something will always go wrong, can we tell what happened fast enough to fix it? Can we observe the system's behavior without having to read every line of code it contains? Observability and accountability at the system level are becoming more important, not less.

Practically: Teams need to invest heavily in logging, metrics, tracing, and alerting infrastructure — not as an afterthought, but as the new definition of quality itself.

5. The Entire Abstraction Stack (Languages, Frameworks) Will Start to Shift

This is the boldest prediction in the series. Every programming language, framework, and abstraction we've built — from FORTRAN to Python to React — exists to solve the same underlying problem: humans have limited cognitive bandwidth, and raw machines don't care. Take the human author out of the picture, and most of these justifications evaporate. Agentic coding systems don't need readable syntax. They can read assembly, reason about memory layouts, and optimize at a level of detail that would exhaust a human developer in minutes.

The prediction: Within a decade, possibly sooner, the tools we use to build software will look fundamentally different. The teams and organizations that allow agents to work at lower levels of abstraction, closer to the hardware, will produce software that is faster, cheaper to run, and more efficient by orders of magnitude compared to teams still running agent-generated code through layers of human-friendly abstraction.

6. "Small Steps" Shifts from Code to Product

One of the most nuanced insights: The bottleneck of developer speed is disappearing. The question used to lean heavily toward: can we break this code problem into smaller pieces so we can learn as we go? The question now leans toward: can we break this problem space into smaller deliveries so we can validate what the market actually needs as we go? Agentic coding makes it faster and cheaper than ever to build the wrong thing at scale — that changes the risk profile considerably.

Speed of building is no longer the bottleneck. Speed of understanding what to build is the new constraint.

What This Means in Practice — The 6 Things That Will Matter Most

Synthesizing all three articles, here's what will be most critical in the coming 2–3 years:

1. Fluency in directing AI agents, not just using them as autocomplete. The developers who thrive will treat agents as junior teammates to be managed, not tools to be prompted.

2. Problem definition as a core skill. Knowing what problem you're solving, and being able to specify "done" with precision, becomes the highest-value human capability.

3. System-level observability as the new quality standard. Investing in how systems are monitored and understood replaces obsessing over how code is written and structured.

4. Product incrementalism over code incrementalism. Releasing smaller, validating faster, treating assumptions as hypotheses — because building the wrong thing fast is now the primary risk.

5. Human accountability as a differentiator. There are decisions being made in software that have real consequences for real people. Humans need to be able to understand those decisions well enough to own them. That's not a coding standards question. It's an ethics question. The firms that maintain clear human accountability will be trusted more.

6. Strategic repositioning before it feels necessary. The developers who will be best positioned in three years are the ones who started genuinely engaging with agentic coding today. The time to move is when it still feels optional. By the time it feels necessary, the most valuable positions are already taken by the people who moved early.

Source: Doc Norton is Vice President of Delivery at Test Double and has extensive experience in building great software and great teams, including focuses within his career in software development, software architecture, product management, technology leadership, agile coaching, organizational agility, and systems thinking.