When Vibe-Coded Software Hits Production: The Patterns We Keep Cleaning Up
Over the past year we have inherited a growing number of codebases built heavily with AI assistance. The failure modes are starting to repeat. Here are the ones we see most often.
Vibe Coding vs Engineers: The Difference Is Still Judgement
The real debate is not whether AI replaces engineers. It is what engineers actually do that AI still cannot, and why those skills are quietly becoming more valuable, not less.
Vibe Coding, Honestly: What It Is, What It Isn't, and Where It Breaks
Vibe coding has gone from a Karpathy post to a full cultural moment in under a year. Here is what it actually is, where it works well, and the specific places it quietly falls apart.
RAG Is Not Magic: Why Your Retrieval Is Quietly Failing You
Retrieval-augmented generation is pitched as the answer to 'make the LLM use my data'. Most implementations are worse than they appear. Here is where the rot usually is.
Pragmatic Testing for Small Teams: What to Skip, What to Keep
Most testing advice is written for teams with full-time QA engineers. For small teams, the question is different: what tests are actually worth the effort to write and maintain?
In Defence of the Monolith
Microservices are often the answer to a question nobody asked. Here is why starting with a monolith is usually the right call, and what the exceptions actually look like.
Designing APIs That Are Actually a Pleasure to Maintain
A bad API is forever. Here is what we think about when designing APIs that need to be owned and evolved over time without becoming a liability.
What Shipping Atlassian Plugins Taught Us About Building for Other People's Platforms
Building inside someone else's ecosystem is a different discipline to building your own product. Here is what we learned the hard way.
LLMs as a Development Tool: An Honest Assessment
After using AI tools heavily in day-to-day engineering work, here is where they genuinely help, where they create more work than they save, and what we have changed our minds about.
How to Hand Over a Software Project Without Making Everyone Miserable
Good handovers are rare. Most teams only discover the documentation is missing when they need it. Here is what a proper handover actually looks like.
Database Migrations That Don't Cause Downtime
The migrations that bring down production are rarely the ones you were afraid of. Here is the pattern we follow to make schema changes safely on live systems.
Building AI Agents That Actually Do Useful Work
Everyone is building agents. Most of them are not production-ready. Here is what separates the demos from the ones that genuinely work.
The Real Cost of Technical Debt
Everyone knows technical debt is bad. What is less understood is how it compounds, when to pay it down, and how to have that conversation with people who control the budget.
How We Decide When to Build vs Buy
Custom software is not always the answer. Here is the framework we use with clients to figure out which approach actually makes sense.
Writing Webhooks That Don't Ruin Your Weekend
Webhooks look simple until you put them in production. Here are the specific things that go wrong and the patterns that actually make them reliable.
Why Most AI Integrations Fail in Production
The gap between a working demo and a reliable AI feature is wider than most teams expect. Here is what goes wrong, and how to avoid it.
The Security Basics Small Teams Keep Getting Wrong
Most security incidents in small teams are not caused by exotic attacks. They are caused by the same handful of basics, missed for the same handful of reasons. Here is the short list that matters.