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.
The Edge vs the Origin: Where Your Code Should Actually Live
Every platform wants you to move your code to the edge. For some things that is excellent advice. For others it is a trap. Here is how we decide.
Why Your Next.js App Is Slower Than It Should Be
The most common performance mistakes we see in Next.js projects, and what to do about them without a complete rewrite.
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 Accessibility Checklist Most Teams Skip (And Regret Later)
Accessibility is the work that gets deferred until the lawsuit arrives or the big customer asks. Here is the short list that catches most issues and takes a week, not a quarter.
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.
Core Web Vitals in 2026: What Actually Moves the Needle
The metrics have shifted, the thresholds have tightened, and most teams are still optimising for yesterday's numbers. Here is what actually matters now, and where the biggest wins usually hide.
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 Future of AI in Software Development: Beyond Code Completion
AI is reshaping how software gets built — but the real transformation goes far beyond autocomplete. Here is what we are observing and building with in production.
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.
Forge vs Connect in 2026: Which Atlassian Platform Should You Actually Bet On?
The answer used to be 'it depends'. It still is, but the balance has shifted. Here is how we think about the Forge vs Connect decision for new Atlassian apps in 2026.
Building Atlassian Plugins That Scale: Lessons from the Marketplace
After shipping multiple plugins to the Atlassian Marketplace, here are the architectural patterns and hard-won lessons we wish we had known from day one.