Blog
-
Posted on
Ten rules for software that doesn't fall over
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-disciplineYou can’t optimize your way to scale. You design for it, then you verify it.
-
Posted on
Making AI write like a person
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 -
Posted on
One skill that gates done on evidence
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-verifyRepo: olakunlevpn-meta-verify
-
Posted on
Prove the bug before you touch the code
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 -
Posted on
Seven reviewers on your build, none of them optimists
“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 -
Posted on
No page gets built without a design
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 -
Posted on
React standards so components stop fighting each other
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-skillsRepo: olakunlevpn-react-skills
-
Posted on
Deploys I don't have to think about
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 -
Posted on
Commit messages that don't make me wince
“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 loganswering your question andgit logwasting 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-skillsRepo: olakunlevpn-git-skills
-
Posted on
Filament v5, built the same way every time
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 -
Posted on
My Laravel standards, written down so the agent follows them
Every Laravel project drifts. One controller does too much, a model grows a tail of helper methods, validation ends up living in three places. I got tired of correcting the same things, so I put my standards in a skill and let the agent enforce them.
Laravel Coding Standards covers the parts that rot first: models, controllers, services, actions, traits, tests, config, exceptions, providers, package structure. These aren’t opinions for their own sake. They’re the conventions that keep a codebase readable at month six, when the person reading it isn’t you.
The agent applies them while it writes, not after. So the review is shorter, because the code turns up already in the shape I’d have asked for.
It’s built for production apps and packages, and it runs across the AI agents I use day to day.
npx skills add olakunlevpn/olakunlevpn-laravel-skills -
Posted on
The skill that keeps junk out of my commits
I’ve committed a .env by accident. Once is enough. Clean Export Skills is the guardrail I wrote so it doesn’t happen again.
Before any git add or zip, it scans what’s about to go in. Source files pass. Agent configs, plan files, AI rule files, stray markdown, secrets, those get stopped. It keeps a .exclude list so the decision is remembered, not re-argued every time. And it never runs
git add ., which is where most accidents start.When it hits a file it doesn’t recognize, it doesn’t guess. It flags the file and asks. That one habit has caught things I’d have committed on autopilot.
Zips get the same treatment. Real folder structure, project files only, nothing from the agent’s workspace riding along.
It works with Claude Code, Cursor, Cline, Gemini and 40+ other agents.
npx skills add olakunlevpn/olakunlevpn-clean-export-skills -
Posted on
Making AI output read like a real document
Ask an AI for a status report or a plan and you usually get a wall of markdown. Fine to read, ugly to share. I wanted the output to look like something a person laid out, so I built a small CSS library and a set of agent skills around it.
That’s Artifact Skills. A light stylesheet plus skills that tell the agent how to use it: reports, plans, reviews, explainers, diagrams, slide decks. The agent writes one self-contained HTML file with a real color system, real typography, and components that fit together. No framework, no build step, no calls out to a CDN.
The point isn’t decoration. A plan with a proper risk table and a milestone list gets read differently than the same words in a flat bullet dump. Structure carries meaning. When the artifact looks finished, people treat the thinking behind it as finished too.
It runs across Claude Code, Cursor, Cline, Gemini and the other agents that read skills, so I’m not rewriting the same styling notes in every tool.
npx skills add olakunlevpn/olakunlevpn-artifact-skills -
Posted on
Welcome to the blog
New blog, first post. Short one.
I kept telling myself I’d write things down. The auth bug that took a whole evening, the deploy step I always forget, the Laravel trick I rediscover every few months and then lose again. I never did. So here’s the fix: a place to put it, public, where forgetting costs more.
What goes here
Working notes, mostly. Laravel and PHP, some JavaScript and Vue, a bit of React, and whatever AWS throws at me that week. When something breaks and I figure out why, that’s a post. When a pattern finally clicks, that’s a post too.
No filler. If it didn’t save me time, it doesn’t go up.
How it’s built
This site runs on Jekyll with the Libretto theme, hosted free on GitHub Pages. The RSS feed at /feed.xml updates on every build, and a small GitHub Action pulls the latest posts straight onto my profile README. Write once, it shows up in both places. That’s the kind of thing worth writing down.
More soon.
subscribe via RSS