What 42 Days of AI Actually Did to a 9-Year-Old Production System
“AI made me faster” is the wrong story.
What actually happened is that it changed how the system evolves.
The Context
For the past 9 years, I’ve been building and maintaining a production platform called WhereWeLearn, powered by a custom PHP engine (LEAST).
It’s not a greenfield system. It’s not built on a modern framework. It has:
- global variables
- manual SQL
- evolving architecture
- real users across 130+ countries
Like most long-lived systems, it accumulated complexity over time.
Then, 42 days ago, I introduced AI into the engineering workflow.
The Measurable Change
The easiest thing to measure is speed.
From the latest report:
- Pre-AI: 0.18 commits/day
- With AI: 2.17 commits/day
- Increase: 12.1×
And:
- 93 out of 123 commits (75.6%) are AI-assisted
- ~558,000 lines removed across the AI period
- Documentation grew from 108 to 154 files in 12 days
Those numbers are real.
But they’re not the most important thing.
What Actually Changed
1. From Linear Work to Feedback Loops
Before AI, development followed a familiar pattern:
design → implement → test → wait → iterate
Each cycle took time. Each change had friction.
With AI, that loop collapsed:
design → generate → validate → inject → review
Instead of waiting hours or days to test an idea, I can test it in minutes.
That doesn’t remove thinking. It amplifies it.
2. From Feature Development to System Evolution
In 42 days, the system didn’t just gain features. It changed shape.
In the most recent 12-day period alone:
A full content injection pipeline was built
- external generation
- validation
- deduplication
- API injection
- review queue
- publish workflow
Multi-language support reached practical completeness (EN, IE, CH, ES)
- A nine-phase persona audit system was introduced across all user types
- The CRON engine was fully normalised, with scheduling moved into the database
This wasn’t incremental work.
It was architectural change.
3. Complexity Reduced While Capability Increased
This is the part most people miss.
Normally, when systems evolve:
- features increase
- complexity increases
- maintainability decreases
In this case:
- features increased
- code decreased (~558,000 lines)
- structure improved
That only happens when:
- decisions are made quickly
- inconsistencies are exposed early
- refactoring becomes continuous rather than deferred
AI didn’t cause that directly.
It made it possible to do it consistently.
4. Governance Was Preserved (and Strengthened)
One of the biggest misconceptions about AI-driven systems is that they become uncontrolled.
In this case, the opposite happened.
The pipeline does not publish content automatically.
It does this instead:
- Generate lesson externally
- Validate structure and duplication
- Inject into system via API
- Place into review queue
- Require human approval before publish
Every step is:
- auditable
- logged
- reviewable
AI increased speed.
It did not remove control.
5. Constraints Didn’t Disappear — They Became Design Inputs
This system still runs under real-world constraints.
For example:
- hosting environment does not allow Python packages
- orchestration must run externally
- platform must remain stable and live
Instead of working around those constraints, the system was designed with them:
- Python pipeline runs locally
- API layer isolates injection
- CRON system handles internal execution
AI didn’t remove constraints.
It made it easier to design around them.
What Didn’t Change
This is just as important.
- There is still no framework
- There is still no traditional test suite
- The system is still a 9-year-old PHP codebase
But:
- validation is enforced through schema + pipeline
- audit logs track every action
- review gates control publication
The safety model changed.
Not the fundamentals.
What This Really Is
This is not about AI generating code.
It’s about a shift in operating model.
From:
slow, cautious iteration constrained by effort
To:
rapid, structured iteration constrained by judgement
The limiting factor is no longer:
- typing speed
- boilerplate creation
- implementation time
It’s:
- clarity of thinking
- quality of decisions
- understanding of the system
The Most Important Insight
AI did not improve the system by itself.
It forced better thinking.
- unclear ideas fail faster
- weak structure breaks immediately
- inconsistency becomes obvious
That creates a different kind of engineering environment.
One where:
- iteration is cheap
- feedback is immediate
- improvement is continuous
Where This Leads
After 42 days, the system is:
- faster to evolve
- easier to understand
- safer to operate
- more structured than it has ever been
And importantly:
- still under control
- still governed
- still human-reviewed
Final Thought
The narrative around AI often focuses on replacement.
That’s not what this is.
This is augmentation at the system level.
Not:
“AI wrote code for me”
But:
“AI changed how the system can change”
And that turns out to be far more powerful.
