We aren’t just waiting for the future of coding to arrive, we are building it. Every time we move from writing lines to reviewing diffs, we are redefining what it means to be a developer. We are in the driver’s seat of a car that’s being upgraded while we’re doing 160 km/h on the N1, in a 60 zone. Crazy, scary, and exhilarating.
Dan Shapiro’s ideas around the journey from spicy autocomplete to the dark factory really made me stop and think. Not because it predicts the future perfectly, but because it forces an honest question: where are we actually right now?
Every commit, every AI generated pull request, every workflow experiment feels like a small shift in how we build software. Nobody has a clear map. We are figuring this out as we go, while still trying to ship real systems that people depend on.
The theory sounds wild. Humans describe intent, machines implement everything. But in reality, what I am doing today is far more structured than that.
I have rails everywhere
There is an agents.md contract that defines how AI agents behave and what they are allowed to touch. Prompt structures are versioned and reviewed. Security scanning happens during generation, not just at the end. CI pipelines enforce architectural boundaries and dependency rules before a pull request even lands in front of a human.
Some of the things keeping this from turning into chaos:
- agents.md defining agent behaviour and scope
- structured prompts with validation checks
- automated security scanning during generation
- CI/CD policy gates blocking unsafe patterns
- architecture validation rules
- test coverage requirements before PR creation
- restricted paths that agents cannot modify
- deployments that still require a human decision
It is fast, but it is not reckless.
My current workflow looks something like this. A story gets created and refined the way it always has. A developer uses AI to turn that story into a structured spec prompt. AI generates the implementation and the tests. AI opens the pull request. Humans review, challenge, and merge.
So yes, AI is writing more of the code. But humans are still deciding direction and carrying responsibility.
If the dark factory is the end goal, I am somewhere in the middle of that road. The AI is doing real implementation work across multiple files and modules, but every change still goes through human judgement. Trust is not automatic. It is built slowly through structure and experience.
Smaller is better said no one ever, right?
One thing that keeps standing out to me is how much faster smaller teams can move here. Large organisations were built to coordinate humans. Standups, planning sessions, approval layers, governance boards, all of it exists for a reason. But when implementation suddenly happens in minutes instead of days, coordination becomes the slowest part of delivery.
Smaller teams simply have less weight to carry. They can change direction faster. They can experiment with autonomous workflows without months of alignment meetings. It does not mean they are better. It just means they can turn the wheel quicker.
This also makes me wonder if we are finally seeing what agile was meant to be. For years, agile became ceremonies and checklists. Standups, sprints, retros. But the original idea was simple: reduce the road between an idea and a real outcome.
AI exposes something uncomfortable. Many of us were not actually agile. We were structured. Now that implementation friction is disappearing, the real bottlenecks are clarity and decision making.
And that changes what it means to be a software engineer. Less typing. More thinking. More clarity in specs. More responsibility for architecture and outcomes.
It feels less like being a builder and more like being a director making sure the story actually makes sense.
Professionally, I still operate inside the rules. Governance matters. Processes exist for a reason. My day job reflects that balance between speed and accountability.
But personally, after hours, I push much harder into this space. That is where I experiment with dark factory patterns, test limits, and stay in the trenches with others who are curious enough to explore where this is going. For me, fear usually means I do not understand something yet, and the only way to understand is to build.
So where does that leave me?
Somewhere between structure and experimentation. Between responsibility and curiosity. Between the road and whatever comes after it.
Maybe I have been scared of the wrong thing. Maybe the speed is not the problem. Maybe the speed is actually the solution.
Because the more time I spend inside this car, the more it feels like it was never meant to stay on the road forever.
And maybe the real realisation is this: the car does not need better tyres.
It can fly.
Emile — written from somewhere between the road and whatever comes after it