Olakunle's Blog

Ten rules for software that doesn't fall over

Thu, 09 Jul 2026 09:00:00 +0000

Most apps don’t break because of a bug. They break because they grew, and the design never planned for it. The query that was fine with ten rows crawls at ten million. The email that sent inline now makes every user wait. The controller that did one job quietly took on five. I kept hitting the same failures across projects, so I wrote them down and turned them into an agent skill.

Scaling Discipline is ten principles for building systems that stay predictable under load. It’s language-agnostic on purpose. A queue is a queue whether it runs on Redis, SQS or Kafka. An N+1 query is an N+1 query in any ORM. The rules hold in Node, Python, Go, PHP, Ruby, whatever you reach for.

The short version:

Dependencies aren’t productivity. Master patterns, not packages.
The data layer is a bottleneck, not a bucket. Index, cache, kill N+1, profile before you guess.
Queues are oxygen. If it can wait, make it async.
Events decouple logic. Emit events, isolate side effects.
Telemetry is your radar. Read the logs on a normal day, not during a fire.
Scalability isn’t speed. Fast is a snapshot. Scalable is consistency under load you didn’t predict.
Design systems, not code. Ask where a feature belongs before asking how to build it.
Mindset beats tools. A bigger server postpones a design problem, it doesn’t fix it.
Reuse before you build. Check what already exists, follow DRY, and don’t over-engineer the other way.
Verify. Trust nothing, prove everything, and don’t call it done below 0.9 confidence.

That last one is the whole point. Systems fail less from missing code than from a false belief that they’re finished. So the skill makes the agent trace the real execution path and confirm every piece is wired before it signs off on anything.

It installs in one line and runs across Claude Code, Cursor, Gemini and 40+ other agents:

npx skills add olakunlevpn/olakunlevpn-scaling-discipline

You can’t optimize your way to scale. You design for it, then you verify it.

Repo: olakunlevpn-scaling-discipline

Making AI write like a person

Wed, 08 Jul 2026 12:35:00 +0000

You can feel AI writing before you can name it. The em-dashes. The “delve” and “seamless” and “it’s worth noting.” Lists always in threes. Every sentence the same middling length. Human Writing strips all of it.

The skill is a checklist built from the actual fingerprints of machine text. It kills the banned words, breaks the triads, varies sentence length on purpose, cuts the throat-clearing first line, and puts contractions and a bit of opinion back in. Then it runs a six-point pass before handing the draft over.

Every post on this blog went through it, including this one. That’s the test I care about. If the skill can’t make my own writing sound like me, it isn’t done.

npx skills add olakunlevpn/olakunlevpn-human-writing

Repo: olakunlevpn-human-writing

One skill that gates done on evidence

Wed, 08 Jul 2026 12:05:00 +0000

I had two skills that belonged together. One enumerates what a build is supposed to do and audits it from seven angles. One proves a claim against real code before anyone touches it. Meta-Verify runs them as a single loop.

Phase one builds the checklist and audits it. Phase two takes each item and proves it. A pass with no trace to code gets downgraded to unverified. A failure becomes a real investigation with an evidence ledger, not a guess. The run ends in a report with a confidence score, and any item still unproven means the verdict is not done.

It’s the shortest honest answer to “is this finished?” Enumerate, prove each item, report. Nothing ships on assumption.

npx skills add olakunlevpn/olakunlevpn-meta-verify

Repo: olakunlevpn-meta-verify

Prove the bug before you touch the code

Wed, 08 Jul 2026 11:35:00 +0000

Most bad fixes come from the same move. See a symptom, change something nearby, hope. Root-Cause Discipline stops that move cold.

Before any edit, it makes the agent earn the right to edit. Understand what the code is supposed to do. Reproduce the failure. Trace the symptom to the exact line and prove the mechanism, not a hunch about it. Map every caller and consumer the change could touch. Then, and only then, make the smallest change that kills the cause. All of it goes into an evidence ledger, and a confidence gate blocks the edit until the proof holds. Under threshold, it stops and asks instead of guessing.

I built this because a fix aimed at a symptom doesn’t remove a bug. It relocates it. This is the “before the change” half of my workflow, and it hands off to the verification skill once the fix is in.

npx skills add olakunlevpn/olakunlevpn-root-cause-skills

Repo: olakunlevpn-root-cause-skills

Seven reviewers on your build, none of them optimists

Wed, 08 Jul 2026 11:05:00 +0000

“It’s done” is the most expensive phrase in software. Meta-Cognitive Verification exists to test it.

After a build, the skill runs the whole thing past seven perspectives: QA, Product, Project Manager, Tech Lead, Business Analyst, DevOps, and Stakeholder. Each one wants evidence. It traces data contracts field by field, so the camelCase the frontend reads actually matches the snake_case the backend sends. It hunts for dummy data, debug logs, half-built pages, missing auth. Nothing passes on a vibe.

The output is a report with a confidence score and a verdict, not a thumbs up. Below the bar, it tells you what’s blocking and refuses to call the work done.

This is the “after the change” half of how I work. The partner to it, root-cause, runs before the change. Both go across 40+ agents.

npx skills add olakunlevpn/olakunlevpn-meta-cognitive-verification

Repo: olakunlevpn-meta-cognitive-verification

No page gets built without a design

Wed, 08 Jul 2026 10:35:00 +0000

Here’s a failure I kept hitting. The agent invents a page from scratch, fills it with dummy data, and now the frontend matches neither the design nor the backend. Design-First Frontend Skills makes that impossible.

The rule is blunt. Every page starts from a pre-built design folder. The agent checks for the design first and never assumes one doesn’t exist. Backend data is the source of truth, so dummy data gets pulled out and real data wired in. What you end up with is one consistent look across the whole app, not a dozen improvised pages that almost match.

It’s the skill I reach for whenever a project has a real design system to honor. Runs on Claude Code, Cursor, Cline, Gemini and 40+ agents.

npx skills add olakunlevpn/olakunlevpn-frontend-first-skills

Repo: olakunlevpn-frontend-first-skills

React standards so components stop fighting each other

Wed, 08 Jul 2026 10:05:00 +0000

React gives you ten ways to do everything, which is fine until a team uses all ten. State handled differently in every component, effects doing too much, types loosened to make an error go quiet. React & Next.js Skills settles those arguments before they start.

It covers components, hooks, state, testing, performance, TypeScript patterns, server components, and project structure. The agent writes to those conventions, so a component I open next month reads like the one sitting next to it. That’s consistency I don’t have to police in review.

It’s aimed at real React and Next work, not toy examples, and it runs across the AI agents I use.

npx skills add olakunlevpn/olakunlevpn-react-skills

Repo: olakunlevpn-react-skills

Deploys I don't have to think about

Wed, 08 Jul 2026 09:35:00 +0000

The scariest part of a small project is usually the deploy. A manual sequence, a step you forget, a site down while you try to remember it. Deployment Skills turns that into a script.

It generates the deploy scripts for Laravel and Inertia apps: pull, install, migrate, cache, restart, in the right order, with logging and error handling so a failure tells you where it stopped instead of leaving you guessing. It sets up the cron for auto-deploy too. The sequence gets written once and runs the same way every time.

Predictable beats clever here. I want deploys boring, and this makes them boring.

Runs across Claude Code, Cursor, Cline, Gemini and 40+ agents.

npx skills add olakunlevpn/olakunlevpn-deployment-skills

Repo: olakunlevpn-deployment-skills

Commit messages that don't make me wince

Wed, 08 Jul 2026 09:05:00 +0000

“fix stuff.” “update files.” “changes.” Open an old repo and the log tells you nothing. Git Workflow Skills is my answer to that.

It holds the agent to a real standard: Conventional Commits, a 50 character subject, the 72 rule for the body, imperative mood, one logical change per commit. No sneaking two changes into a message with an “and.” And no AI attribution, not once. My commits are mine.

Small rules, but they add up. A clean history is the difference between git log answering your question and git log wasting your afternoon.

It triggers on any git activity and runs across the same 40+ agents as the rest of the set.

npx skills add olakunlevpn/olakunlevpn-git-skills

Repo: olakunlevpn-git-skills

Filament v5, built the same way every time

Wed, 08 Jul 2026 08:35:00 +0000

Filament is fast to build with and easy to build inconsistently. Two developers, two ways to wire a form, and the panel starts to feel stitched together. This skill pins down one way.

Filament PHP v5 Skills covers 18 areas: resources, forms, tables, infolists, actions, widgets, panels, relation managers, multi-tenancy, testing, plugins. When the agent builds a resource, it follows the same structure as the last one. CRUD pages line up. Destructive actions get a confirmation step. The admin stops looking like a patchwork of whoever touched it last.

I lean on Filament for the admin side of most projects, so consistency there pays back fast. Less to explain, less to fix, and no nasty surprise when I open a resource I wrote three months ago.

Works with Claude Code, Cursor, Cline, Gemini and 40+ agents.

npx skills add olakunlevpn/olakunlevpn-filament-skills

Repo: olakunlevpn-filament-skills