# What’s Old Is New Again

> The future of AI-assisted software development looks suspiciously like the past.

- URL: https://www.geordie.ai/resources/whats-old-is-new-again/
- Author: Valerie Dryden
- Published: 2026-11-17
- Type: Blog
- Topics: Governance & Compliance

---

## The future of AI-assisted software development looks suspiciously like the past.

There's a lot of noise at the moment about pull requests (PRs) and the bottleneck of human code review.

Git isn't fit for purpose. Pull requests are pointless. Code review doesn't scale. We need entirely new workflows, new tools, new paradigms.

Maybe we should just trust the machine.

But generating and approving code was never the whole job. Understanding what we're building, how it fits together and what might break when we change it is where the real engineering happens.

A pull request is considerably less useful when it's the first opportunity anyone else has had to question the design, understand the implications or discover that half the architecture has changed.

That goes for human and agent reviewers.

And this is where I think we're getting AI-assisted development spectacularly backwards.

One camp wants to scrap review because it can't keep up. The other wants to keep it, but at machine speed: more agents producing more code, other agents reviewing it.

**Both are trying to fix the last step instead of the whole process of developing software.**

Either way, humans risk becoming increasingly removed from decisions they're still expected to be accountable for.

Which may not matter when you're making a dating app for your cat. Slightly more concerning when your software handles real customer data, moves money (or crypto, ouch) or wakes somebody up at 3am.

## What we already know

We've become so distracted by how quickly we can produce software that we've forgotten most of what we know about building it well.

And the funny thing is, we've had some pretty good answers for decades that we've often chosen to ignore.

Take Extreme Programming (XP) and the practices that grew out of it. XP is a collection of engineering practices that help people work together, get fast feedback and take collective responsibility for the software they build.

It was built around some remarkably sensible ideas:

**Shorten the feedback loop. Reduce the size of changes. Make quality part of the work. Share knowledge and decisions. Integrate continuously.**

All things that matter a lot more when your colleague, human or agent, can produce hundreds of lines of code before you've finished your coffee.

- **TDD (test driven development)** gives us a way to establish expected behaviour and get rapid feedback as code changes. Pretty useful when an agent can produce something confidently wrong at impressive speed.
- **ATDD (acceptance-test-driven development)** gets people talking about what we're actually trying to achieve before implementation. Being clear about expectations before unleashing an army of enthusiastic agents is quite helpful.
- **Pair and ensemble programming** bring different perspectives into the work while decisions are being made. Whether we're collaborating with humans or agents, the point is to challenge assumptions and share ideas early, while we still have the context.
- **Small batches, trunk-based development and continuous integration** stop us accumulating enormous piles of work that nobody can reasonably understand or validate.
- **Continuous delivery** means we can keep making progress without turning every release into a saga.

None of these practices require us to throw out Git or abandon review.

They require us to think about **when and how we get feedback, who understands the work, and where responsibility sits.**

At Geordie, we’ve found that sticking to these principles as best we can makes PRs far less painful. We default to pairing on workstreams, breaking off to work individually with agents and then coming back together. That way, conversations about design and implications happen early and often, rather than as a surprise at the PR.

## What AI hasn't changed

Agents can absolutely help us practise XP. They can support testing, explore implementations, provide rapid feedback, help us refactor and make small changes easier.

But someone on the team still needs a working mental model of the system. What we're building, why we're building it, how it fits together and what the consequences might be.

That understanding develops through the work, as we make decisions, test assumptions and learn things.

You can't expect someone to reconstruct it all from a PR after an agent has finished.

And that's true whether the code was written by a human or an agent.

AI has given us the ability to produce code at a frankly ridiculous rate. But more code doesn't automatically mean better software. Sometimes the best engineering decision is not to write any more code at all.

So perhaps instead of reinventing Git or building an army of agents to speed-run LGTM, we should be using AI to make the engineering practices we already know work even better.

Faster feedback. Smaller changes. Better decisions. Quality built into the process, with people who understand and take responsibility for what gets shipped.

**The future might need a lot less reinvention and a lot more remembering what we already know.**
