~/blog/series/ai-skeptic
The AI Skeptic
Using AI without outsourcing your thinking.
What this series is about
This series starts from a position. Most of the problems people blame AI for are not actually new. They are old problems that nobody had a reason to look at until generation got cheap.
A team that does not read its own code carefully had that habit before the agent arrived. A pipeline with no tests was a liability long before something was committing to it autonomously. A culture that treats code volume as productivity will treat AI-generated volume the same way, only faster. The model is a magnifier. The pathology underneath is yours.
So the series moves through that diagnosis, roughly in the order worth reading it. Why most production problems are process problems. Why shipping code you do not understand was always a bad idea. Why the prompt is not the spec. What happens to a codebase when nobody can spot the bug. And what it looks like when a bureaucracy of bots starts checking other bots.
I am not against AI in software work. I use it every day, and several of these posts are about how. But I am against the framing that treats the agent as the protagonist of the story, when the protagonist has always been the team that decides what ships.
Where this is going
I expect the centre of gravity of this series to shift over the next few months. The shock of the first wave is wearing off, and what is left is the slower question of what habits actually hold up. There is at least one more post coming on what teams that survived the early hype have started doing differently. If you spotted a pattern I have missed, the contact page is open. And if you would rather put this thinking to work on your own project, that is what my consulting is for.
Why you should never ship code you don't understand
If you can't explain your code to a colleague without saying 'the AI wrote that', it doesn't belong in your repo. On black boxes, self-validating tests, and why hope is not a strategy.
Stop copy-paste engineering
We're breeding a generation of developers sprinting full speed toward a cliff. On AI hallucinations, echo chamber tests, and why your brain is the only real debugger.
The lava layer: why AI code is slowly petrifying your codebase
We’re building faster than ever, but at what cost? Exploring the invisible accumulation of code that no one truly understands and why your application is turning into impenetrable rock.
The prompt is not the spec
Developers are treating AI prompts like requirements documents. They're not. On vague intent, confident hallucinations, and why the wrong thing built fast is still the wrong thing.
The brilliant parrot problem: what AI actually does when it 'thinks'
Transformers are extraordinary algorithms. But they are algorithms. On next-token prediction, the blindness of generation, and why a system that cannot see where it's going almost certainly cannot be conscious.
The bureaucracy of bots: why we are checking the checker
Deploying an AI to double-check the work of another AI produces better results. But we are unwittingly recreating the slow, complex corporate bureaucracy we tried to escape.
The arms race for your trust: Mythos, Cyber and the security hype
Anthropic and OpenAI are fighting for market share with AI security tools they call "too dangerous" to release. But the facts tell a different story than the press releases.
Stop letting your agents write Markdown
Everyone is excited about AI agents generating HTML instead of Markdown. The output looks beautiful. But nobody is asking what it costs, or what we lose when every agent response becomes a single-use webpage.
You can't spot the bug if you didn't write the code
AI isn't making you a worse programmer. It's making you a worse reader. On debugging instincts, skill atrophy, and why the biggest gap isn't in writing code but in understanding it.