Here is the irony at the heart of AI-accelerated software development: the best way to get strong results from large language models right now is to use the exact same practices we invented to help imperfect humans build software together. Clear user stories. Well-defined acceptance criteria. Test-first development. Iterative refinement. Structured documentation.

We thought AI would let us skip all that human mess. Turns out it made these things matter even more.

Let me explain.

Software Is the Disciplined Transformation of Data

Software engineering in its purest form is about designing and implementing code to affect an outcome. Computers at the bottom level run on binary. They see the world as numbers. Luckily the real world can mostly be turned into numbers too.

When you strip everything away, software basically only does five things:

  • Read data
  • Output data
  • Assign values to data
  • Compare data
  • Iterate on data

Everything else - sorting, searching, business logic, UIs, networks, whole applications - is just these five operations combined in clever ways.

So why is software hard? Not because the basics are complicated. Because we are.

Abstraction Was Invented for Us, Not for the Machine

To make these raw operations usable, we piled on layers and layers of stuff: low-level languages like Assembly and C, higher-level languages like Python and JavaScript, powerful IDEs, design patterns, and methodologies like Waterfall and Agile.

Anyone who has tried writing machine code knows why. It is brutal trying to keep a clear picture in your head at the numeric level. We needed the abstraction so humans could actually design and build things successfully.

And these methodologies do more than just handle technical complexity. They were built to deal with fundamental human flaws: our biases, ego, limited understanding, poor communication, self-serving behaviour, and the way teams constantly drift into conflict and misalignment.

User stories, acceptance criteria, standups, retrospectives, and test-driven development all quietly work to improve conflict resolution, force alignment, and keep people focused on shared outcomes instead of personal preferences.

Basically, we stacked language and process on top of pure numeric operations so that flawed humans could still make software work.

What We Expected From AI, and What Actually Happened

If software is really just transforming raw data, and the world itself can be represented as data, you would think the quickest and best way for AI to build software would be a pure data-problem to data-solution thing, collapsing everything back down to the low-level primitives without all the human scaffolding.

But that is not what is happening.

Instead, the language abstractions and human-centric methodologies we created are turning out to be more important when working with AI, not less.

LLMs do much better when you give them rich, precise language and guide them with disciplined process. Vague prompts give you vague code. Sharp user stories, clear acceptance criteria, and tests to check against produce code you can actually use and ship.

The same toolkit we built to manage our own fallibility is exactly what gets the most out of these models.

The Harder Question This Raises

If precise language is what makes these systems work so well, then it makes sense to ask whether language itself is also their ceiling.

There is a growing belief in the AI community that LLMs might be a real limitation on the road to AGI. They are great at working with symbols and patterns in language, but predicting symbols brilliantly is not the same as building a grounded, persistent model of the world.

In the same way that Python, Visual Studio, and Agile let us humans move further away from thinking in binary, today's LLMs - as powerful as they are - might be standing in the way of AI that can truly understand the world and act in it.

The same abstractions that help us, and now help AI, build software successfully today may also be what holds the next leap back. Both things can be true at once.

For now, the clear lesson is this: if you want to build well with AI, bring the very discipline we originally created for flawed humans. What that discipline still cannot give us - real grounding in the world behind the data - is exactly where the frontier needs to go next.