Han: Where AI Code Generation Meets Engineering Discipline

The PR Looks Fine

It's Wednesday afternoon. A teammate opens a PR generated largely with an AI coding assistant. The diff is clean. The tests pass. The description is articulate. You approve it because nothing jumps out, and there are four more in the queue.

Three weeks later you're on a call with a customer whose data pipeline started silently dropping records. You pull up the file. The tests assert that a function returns a value — not that the value is correct. A helper swallows errors and returns an empty array. A condition is inverted in a way that reads naturally left-to-right and is exactly backwards. Nothing in the code looked wrong. Nothing failed loudly. The PR had just enough surface coherence to get through, and it's been producing bad data ever since.

This is the gap we keep being called in to fix. AI-assisted code doesn't fail the way careless code fails. It fails quietly, in ways that pass review, because the reviewer is often using the same tools as the author and neither one is forced to reason from first principles. We built Han to close that gap — not by slowing AI down, but by putting real verification in the loop.

What Han Actually Is

Han is a curated set of open-source Claude Code plugins, installable from han.guru. It's MIT licensed. You can read the source, install what fits, and ignore what doesn't. There's no SaaS backend, no telemetry gate, no enterprise tier behind a "contact sales" button.

The plugins are organized around a simple equation: AI capability plus real verification equals output you can actually ship. The "real verification" part is what most AI tooling skips — not because it's hard to build, but because it's unglamorous and slows the demo down.

Han puts the verification back.

Three Pillars

Chi (Knowledge) encodes opinionated, production-grade patterns directly into AI interactions. Not generic documentation scraped from public READMEs — specific framework conventions, anti-pattern detection, and architectural guidance drawn from systems that actually run under load. When the assistant reaches for a pattern, Chi pushes it toward the one that holds up in production rather than the one that reads well in a tutorial.

Ko (Action) provides purpose-built agents and slash commands for multi-step workflows. The principle is narrow: automate the tedious, keep the human in the loop for anything that requires judgment. Ko doesn't try to be your architect. It tries to stop being your typist.

Ritsu (Discipline) enforces quality standards automatically. Pre-commit validation. Smart caching for fast feedback loops. Linting that runs without you remembering to run it. Ritsu is invisible while things are fine, and loud the moment they're not.

The Plugin Taxonomy

Every Han plugin falls into one of four categories.

Bushido plugins are the foundation: proof-of-work verification, code review standards, SOLID enforcement, and professional honesty — having the assistant flag uncertainty rather than confabulate confidence. Install these first. The rest of Han assumes they're there.

Do (The Way) plugins are specialized agents for entire disciplines — Next.js full-stack workflows, CI pipeline optimization, accessibility treated as architecture rather than a retrofit. They're opinionated about how the pieces fit, because "unopinionated" usually means "inconsistent in production."

Jutsu (Techniques) plugins are technical skills bundled with the checks that confirm they were applied correctly. Markdown formatting with structural validation. GitHub Actions tested locally through act before they ever touch a runner. Framework patterns that come with their own verification, so "I used the pattern" and "the pattern is working" stop being separate questions.

Hashi (Bridges) plugins connect Han to external systems — Context7 for live documentation, GitHub for version control context. The goal is to stay in your editor while pulling in the context your tools already have.

The full plugin marketplace is at han.guru. Browse before you install.

Why Discipline, Not Speed

Our industry has a complicated relationship with craftsmanship. We talk about it in conference keynotes and ignore it in sprint planning. AI has made the tension sharper, not softer. When generating code costs nothing, the temptation to skip verification is enormous. Why write a careful test when you can regenerate the whole module? Why read the diff slowly when the assistant "probably got it right"?

That incentive is where the quiet failures come from. It's also where the Bushido virtues stop being decoration and start mapping to specific engineering practices.

• Rectitude: the code does exactly what it claims — no hidden side effects, no undocumented behaviors.
• Courage: delete what no longer serves the system; refactor when not refactoring is more expensive than refactoring.
• Benevolence: write for the engineer who inherits the code, not just for the sprint that ships it.
• Honesty: document what the system actually does, not what you wish it did.
• Honor: own what ships. When it breaks, fix it, don't blame the assistant.
• Loyalty: commit to sustainable quality — no shortcut that becomes next quarter's incident.

These aren't abstract values. They're the checks that would have caught the Wednesday PR three weeks earlier.

Getting Started

One command:

npx @thebushidocollective/han plugin install --auto

Auto-detect reads your project structure and recommends the plugins that match your stack. Or install specific ones directly:

npx @thebushidocollective/han plugin install bushido
npx @thebushidocollective/han plugin install jutsu-markdown

No configuration labyrinth. Pick what serves your practice. Start working.

Shu-Ha-Ri

Han is structured around the martial-arts progression of Shu-Ha-Ri, because it maps cleanly to how engineers actually develop expertise with a new tool.

Shu (Follow): use the established patterns exactly as prescribed. Don't improvise. This is where most AI-assisted development breaks — engineers skip to improvisation without the foundation, and the assistant cheerfully helps them.

Ha (Adapt): understand why the patterns work, so you know when to modify them. Break rules productively rather than accidentally.

Ri (Transcend): the patterns are so internalized that discipline becomes invisible. You're not following rules. You're operating from principles.

The progression can't be shortcut. Han's job is to make Shu sustainable long enough that Ha and Ri become possible.

Who This Isn't For

If you want AI to generate code faster and you don't care what comes out, Han will annoy you. The verification steps will slow you down. The quality gates will reject sloppy output. The discipline will feel like friction.

It is friction. Intentional friction — the kind a seatbelt creates. You don't notice it until the moment it saves you.

Han is for teams that understand one thing: AI is an amplifier, not a filter. Bring rigor and you get rigorous output at scale. Bring carelessness and you get an expensive mess at scale. The tool doesn't care which one you feed it — which is exactly why the discipline has to live outside the tool.

Browse the plugins at han.guru. Read the source. Install what fits. And if you're working through how to integrate AI tools into your engineering practice without inheriting the fragility that usually comes with them, we should talk.