Skip to content
Cerosh Jacob
Back to Knowledge Hub
ceroshjacob.comNov 18, 20264 min read

AI is changing how we write software. Are our engineering practices keeping up?

  • ai-engineering
AI is changing how we write software. Are our engineering practices keeping up?

Looking at Microsoft's recent outage alongside Anthropic's decision to move its monorepo away from Git, I think we are seeing two different sides of the same engineering challenge.

Microsoft reminds us that even well-tested systems can fail when real-world conditions expose weaknesses we haven't accounted for. A latent lock-contention bug, combined with changes in traffic patterns during a Teams failover and reduced gateway capacity, exposed a problem that had remained undetected for months.

Anthropic's situation highlights something different. AI agents are generating code at a scale that is beginning to challenge the development infrastructure and workflows we have relied on for years. With more than 30,000 merges a day, their existing Git-based infrastructure was struggling to keep up.

One highlights the complexity of building reliable software. The other highlights the speed and scale at which we are now building it.

These events aren't directly related, and Microsoft's outage had nothing to do with AI. But they raise an interesting question:

As AI starts generating more of our code, are our engineering practices evolving at the same speed?

The human ownership problem

For decades, software engineering has relied on an unspoken contract: human ownership.

When an engineer writes a patch, they develop an understanding of what the code does, why it exists and how it interacts with the rest of the system. That doesn't mean humans always get it right. Microsoft's incident is a reminder that even experienced engineers can miss problems that only appear under very specific conditions.

Now imagine introducing AI-generated code at 10x or 100x human speed into these same engineering workflows.

Our development processes haven't necessarily changed at the same pace. We still depend on human code reviews, pull requests, staging environments and testing processes designed around how humans traditionally write and understand code.

An AI agent generates a complex change. The code looks clean, follows coding standards and passes unit tests. A developer reviews it, perhaps with several other AI-generated changes waiting in the queue, and approves it.

But how deeply have we actually understood what we are approving?

This creates a gap between code generation and code ownership. The AI may not understand every condition under which the code will eventually run, and the human reviewer may not have developed that understanding either.

I think there is an important distinction here. Ownership doesn't necessarily mean writing every line of code yourself. It means understanding the intended behaviour, validating the implementation and taking responsibility for what happens when that code runs.

When our tools reach their limits

Anthropic moving its monorepo away from Git is interesting in this context.

Git has served software engineering extremely well, but it was designed around a particular way of working: developers making changes, committing code, reviewing differences and merging them.

What happens when thousands of AI agents are continuously making changes to the same codebase?

Anthropic's move towards Scion, its internal source control system, highlights the infrastructure challenges that emerge when development activity reaches this scale. It doesn't mean Git is broken or that every engineering team needs a replacement. But it does show that some of the assumptions behind our traditional development tools may need to be revisited.

And this isn't just about version control. Our CI/CD pipelines, code reviews and testing strategies were largely designed around human development patterns. We cannot simply introduce AI into an existing engineering pipeline and expect everything else to work the same way.

Redefining engineering ownership

Moving into this new era doesn't just mean adopting better AI tools. It means rethinking how we approach software engineering.

If we are no longer the primary authors of every line of code, our responsibilities need to evolve.

More attention needs to go into:

  • Specifications: Clearly defining what we want to build.
  • Architecture: Establishing how components should interact.
  • Guardrails: Defining what AI agents can and cannot do.
  • Verification: Establishing whether the implementation meets expectations, including under unexpected conditions.
  • Observability: Understanding how the system behaves in production.

None of these are new engineering concepts. We have been practising them for years. What is changing is their importance when code generation is no longer the primary bottleneck.

Passing unit tests is not enough to establish that a system will behave correctly under every condition. We need stronger combinations of automated testing, static analysis, security checks and continuous verification to build confidence in what AI produces.

The real differentiator

One thing I find interesting about this transition is that the fundamentals of good engineering haven't really changed. We still need clear requirements, good design, reliable systems and proper verification. What is changing is the speed and scale at which we need to apply them.

AI might change how we write software, but it doesn't remove the need to understand, verify and take ownership of what we build.

The teams that succeed in this transition won't necessarily be the ones generating the most code. They'll be the ones who figure out how to maintain engineering confidence and take ownership of software that humans are no longer writing line by line.


AI might change who writes the software, but it doesn't change who is responsible for the software we put into production.