A Glimpse into the Blind Future of Software Development (Feb 2026)

(Note: Edited on Feb 14, 2026 to add a graphic showing the nine layers.)

“Never yet has any man on earth found a reliable token of what will happen from the gods. Our understanding of the future is blind.”
—Pindar, Olympian Odes 12:7-9

Like most people involved in software development, I’ve been thinking a lot about how AI is affecting the profession, and how it will continue to change the profession going forward.

With the tools, ways of working, and discussion in this space moving so quickly, I’m putting this post up as a “time capsule” of my thinking on this as of early February 2026.

In short, I think we are in for more of a change in the next few years than people realize…

Since their widespread launch in 2024, AI agents have become an increasingly powerful tool at writing software.

Engineers are able go from idea to production-quality software faster than ever before, by pairing up with AI agents. Even people who had never before written code are now enabled to produce high quality prototype software, and in some cases, production-ready software.

Since 2023, my own experience using generative AI in coding has looked like this:

• Late 2023: Started using Github Copilot extensively for enhanced autocompletion.

• October 2024: Started using Github Copilot on edit mode for generating code.

• December 2024: Most new features I was working on were mostly written by Github Copilot.

• January 2025: Switched to Cursor and its agent mode. Began writing most of my tests using the agent as well.

• May 2025: Started writing large specs in markdown to assist with writing new features. Used ChatGPT or other web-based chat for breaking the specs into implementation plans, then running the steps one at a time through Cursor’s agent to implement.

• Late 2025: Cursor’s planning mode became my default way of turning specs into implementation tasks.

• January 2026: Switched to Claude Code and OpenSpec to manage the specification-implementation cycle. Started running two agents simultaneously on different copies of my code base to speed up work.

• February 2026: Experimenting with different approaches to using multiple agents.

I think my experience is similar to the journey of many others during this time. What does this journey say about what is next?

We can look at the tasks of software product development as a hierarchy of layers, from the most high-level and abstract, to the most concrete:

• Layer 9: Problem Selection

• Layer 8: Product Vision

• Layer 7: Product Discovery Cycle

• Layer 6: Product Specification & Roadmap Planning

• Layer 5: Feature Specification

• Layer 4: Feature Verification

• Layer 3: Feature Building

• Layer 2: Function/Module Writing

• Layer 1: Coding Individual Lines of Code

As generative AI has progressed over the past two years, we can see that it has been getting more and more capable, and has been replacing humans at the tasks at the bottom of the hierarchy.

With each new evolution of the AI tools and techniques, the AI’s abilities bring it further and further up the hierarchy. First, AI provided good autocomplete, augmenting and replacing humans writing individual lines of code. Then AI started writing whole functions. And then building entire features, etc.

If we turn that layer hierarchy upside down, we can see how AIs have already replaced, and could continue replacing, each layer by automating the job previously done by humans:

1. Coding Individual Lines of Code

   • AI Autonomy at Layer 1: AI suggests the next characters or lines via something like autocomplete.

2. Function/Module Writing — Writing functions and/or code modules that organize the code into larger units.

   • AI Autonomy at Layer 2: AI generates the entire body of a function or multiple functions and modules.

3. Feature Building — Creating multiple functions and modules, and producing a coherent working feature in the product.

   • AI Autonomy at Layer 3: AI implements the entire feature/module based on a prompt or spec.

   • Translation: Humans stop writing code. The role of the human shifts to technical writing, architectural oversight, and verification of the completed feature.

4. Feature Verification — Ensuring the built feature meets the requirements and doesn’t break existing systems.

   • AI Autonomy at Layer 4: AI agents write their own tests, run them in a CI/CD pipeline, and fix bugs autonomously.

   • Translation: Humans no longer look at or verify the code. Humans increasingly verify behavior and risk.

5. Feature Specification — Breaking down the roadmap into granular, actionable requirements for specific capabilities, and creating artifacts like user stories and architecture designs.

   • AI Autonomy at Layer 5: The AI plans features based on product specifications provided by humans.

6. Product Specification & Roadmap Planning — Translating requirement discovery into high-level requirements and a chronological execution strategy.

   • AI Autonomy at Layer 6: AI generates the PRDs (Product Requirement Documents), specifications, and timelines. Humans verify generated plans and trust the AI to implement it.

7. Product Discovery Cycle — Gathering stakeholder input, conducting validation with customer, running A/B tests to find product-market fit, etc.

   • AI Autonomy at Layer 7: AI performs product discovery automatically. AI agents interact directly with users and stakeholder to synthesize feedback. Humans move to a monitoring role.

8. Product Vision — Defining the long-term objectives and the “North Star” for the solution.

   • AI Autonomy at Layer 8: Swarms of agents define the ultimate goal of the software based on problem statements provided by humans.

9. Problem Selection — Determining which fundamental user pain points or market opportunities are worth addressing.

   • AI Autonomy at Layer 9: AI decides which problems are worth solving. AI identifies market gaps or inefficiencies and decides to allocate resources to solve them without human intervention.

   • Translation: The system grows and operates independently of human input. Software development as a human profession ceases to exist.

Power users of coding agents (like Claude Code, Cursor, or Codex) are firmly already at AI Autonomy at Layer 4, where humans are providing specifications and agents implement the feature, write their own tests, and fix bugs autonomously.

Around that layer, swarms of agents start to become possible, and managing many agents at once becomes necessary. See Steve Yegge’s Gas Town for one direction this could go.

At the very far extreme currently, some people are experimenting with AI Autonomy at Layer 6, where humans are only verifying specs generated by the AI, and the AI is running as swarms of agents build the solutions.

And to see even further into the future, check out how this team is beginning to automate AI Autonomy at Layer 7, the Product Discovery Cycle, check out this article about “How StrongDM’s AI Team Build Serious Software Without Even Looking at the Code.”

Note: I was inspired heavily by Dan Shapiro’s “Five Levels” and Steve Yegge’s “Developer-Agent Evolution Model”.

Based on the model above, what are the consequences for the future?

1. The transition from human-led to AI-governed development follows a clear trajectory: the automation of execution, followed by the automation of validation/definition, and concluding with the automation of intent.

2. Software engineers’ roles will change drastically in the near term. Their role will change to fill some combination of the roles architects and product managers filled (or at least should have filled) previously. They will manage teams of agents at the spec level, never writing code, and barely looking at code.

3. For people in the industry, it seems prudent to adapt your job to focus as high as possible on the hierarchy. The higher your focus is on the hierarchy, the less likely you are to find yourself without valuable work to do as AI automation creeps up and up.

4. Companies whose only moat is a suite of software will be replaced by custom AI-agent written software. Companies will need some other real-world moat that protects their business from being replaced by AI-agent written software. Examples of durable moats could be trust, brand, procurement relationships, network effects, etc. As Noah Raford wrote recently, “[T]he essential functionality of most enterprise software can now be described in a few paragraphs and implemented in a few hours by an AI coding agent.”

5. If and when AIs get to Autonomy at Layer 9, Problem Selection, dystopian fears about runaway paper-clip factories or utopian dreams of AIs solving all problems in the world come into play.

But there are some important caveats:

Just because we reach a level of AI autonomy in principle, doesn’t mean all companies will reach it in practice at the same time. Companies at the leading edge, like startups and companies in less regulated industries and markets will be far ahead on AI automation.

In many industries (banking, healthcare, air travel, etc), the need for safe and compliant software means that some parts of automation will be severely restricted until we discover ways to standardize automated safeguards. And large organizations have to deal with the realities of social and political negotiation, so small and new organizations will move much quicker into higher levels of AI autonomy than large and existing organizations.

Finally, maybe some fundamental weakness of our current approaches to AI will keep us from reaching AI Autonomy at Layers 8 and 9. If the AIs cannot reproduce the creativity and imagination of humans, those last two steps may stay the domain of humans for a bit longer.

It’s a strange future ahead for us…

Abrahms, Justin. “Yegge’s Developer-Agent Evolution Model,” January 8, 2026. https://justin.abrah.ms/blog/2026-01-08-yegge-s-developer-agent-evolution-model.html.

Albrecht, Kevin. “The Pyramid of Creativity.” Outcome Focused with Kevin, April 26, 2023. https://outcomefocused.substack.com/p/the-pyramid-of-creativity.

McCarthy, Justin. “Software Factories And The Agentic Moment.” February 6, 2026. https://factory.strongdm.ai/.

Raford, Noah. “The Road Runner Economy.” January 22, 2026. https://nraford7.github.io/road-runner-economy/.

Shapiro, Dan. “The Five Levels: From Spicy Autocomplete to the Dark Factory,” January 23, 2026. https://www.danshapiro.com/blog/2026/01/the-five-levels-from-spicy-autocomplete-to-the-software-factory/.

Willison, Simon. “How StrongDM’s AI Team Build Serious Software Without Even Looking at the Code.” Simon Willison’s Weblog, February 7, 2026. https://simonwillison.net/2026/Feb/7/software-factory/.

Yegge, Steve. “Welcome to Gas Town.” Medium, January 1, 2026. https://steve-yegge.medium.com/welcome-to-gas-town-4f25ee16dd04.

‌