DEV Community

jaehong kim
jaehong kim

Posted on

I Built a Claude Code Plugin Because I Was Becoming a Rubber-Stamp Reviewer

My development team has two members: me and AI. And lately, I've been feeling like I'm becoming the less useful member of the team.

I've been using AI coding agents for years. Claude Code, and plenty of other tools. They're incredible at what they do, but somewhere along the way, my development process started looking like this:

Me: "Implement this feature."

AI: "Done! Changed 27 files, added 3,400 lines, refactored two modules. All tests passed."

Me: "LGTM."

Narrator: He did not, in fact, look.

The code gets written. Features get shipped. Productivity looks great. But here's what bothers me: Am I actually reviewing the code anymore, or am I just approving whatever the AI tells me?

And if I'm not making the technical decisions, what exactly is my role as a developer?

The problem isn't that AI writes code

I don't think developers need to manually write every line of code. That's not the point. The problem is that we're slowly outsourcing something much more important than typing: our judgment.

Think about how often this happens. The AI makes an architectural decision without asking you. It assumes a requirement that was never specified. It changes something outside the original scope. Then it confidently reports that all tests passed, and you trust the summary because reviewing everything yourself would take too long.

None of this necessarily means the AI is bad at coding. It means our development workflow hasn't caught up with how much code AI can produce.

I wanted a workflow where AI could do most of the implementation without quietly taking ownership of the decisions. I also didn't want to become an unpaid project manager, manually breaking everything into tiny tasks and supervising every step.

So I built human-rights.


GitHub: https://github.com/kiduki77/human-rights

AI writes the code. Humans own the decisions.

human-rights is an open-source Claude Code plugin built around a simple idea: Don't make humans review every line. Make sure they understand and approve the decisions that matter.

The requirements. The architecture. The risks. The acceptance criteria. And the evidence that the implementation actually works.

But there's an obvious problem with this approach. If every tiny change requires a design document, three approvals, and a meeting with yourself, nobody is going to use it.

So the workflow adapts to the task.

  1. Not every change deserves the same process

human-rights classifies development requests into four levels, from simple edits to high-risk changes.

Level

Example

Workflow

L0 — Direct

Center a login card

Make the change and check it

L1 — Focused

Add input validation hints

Short plan and targeted tests

L2 — Planned

Add Google authentication

Investigate, design, and review

L3 — Governed

Modify safety-critical control logic

Human approvals, integration tests, and final verification

The classification considers ambiguity, scope, architectural impact, risk, verification difficulty, and dependencies. A small UI change shouldn't require the same process as modifying authentication or controlling physical hardware.

For larger changes, the agent investigates the existing code, asks questions that could change the design, and creates a testable implementation plan. If the request is too large, it first breaks the work into smaller features that can be reviewed and verified independently.

The human decides what should happen. The AI figures out how to implement it.

  1. The AI cannot simply approve its own work

This was one of the most important design decisions. I didn't want to rely entirely on instructions like "Always ask the user for approval." An AI agent following a prompt is not the same thing as an enforced workflow.

So human-rights has two parts: a Claude Code skill that decides what process a task needs, and a deterministic Python runtime that enforces state transitions, approvals, test evidence, and failure handling.

Design approvals are tied to the approved plan, while final approvals are tied to the code being verified. If the plan changes, the previous design approval becomes invalid. If the code changes, the final approval becomes invalid too.

A test result is not accepted just because the agent says it passed. The runtime records the execution result and associates it with the relevant code version.

The goal is simple: stop trusting the AI's description of what happened and start requiring evidence of what actually happened.

  1. Then I realized something worse: humans can still blindly approve everything

Even with all those safeguards, there's a fundamental weakness in the system.

The human.

You can build the most carefully controlled approval system in the world, and I can still click "Approve" without reading anything.

So I added a feature called Red Pill Mode.

Here's how it works. When enabled, the system occasionally introduces a deliberately incorrect item into the review material. The developer is supposed to notice it before approving the work.

For example, suppose the original requirement says:

The system must support four simultaneous drone connections.

But the review table contains:

TEST-010: Verify that two simultaneous drone connections work correctly.

Would you notice the difference? Or would you just approve?

If you catch the incorrect item, the system records the catch and explains why it was wrong. If you blindly approve, the approval is blocked.

And yes, it makes fun of you:

You didn't really review this, did you, human? Keep approving like that and the AI really will take your job. lol.

It's intentionally a little ridiculous, but the underlying problem is serious. An approval button means nothing if the person clicking it isn't paying attention.

The planted mistakes never modify the actual implementation plan or executable code. They exist only in the review material, so they cannot accidentally become part of the software being built.

Red Pill Mode is optional and off by default. It also supports adaptive difficulty, so the review exercises can become harder as you successfully identify mistakes.

I find this particularly interesting because we're entering a world where developers may spend more time reviewing AI-generated work than writing code themselves. If that's where we're heading, shouldn't we be actively improving our review skills instead of letting them deteriorate?

  1. Bigger requests are split before implementation

Another issue I kept encountering was asking an agent to implement something too large. It would produce an enormous plan, and I'd be expected to approve the whole thing.

That's not meaningful review. That's just outsourcing a massive amount of work and hoping the result is correct.

So compound requests are split into independently verifiable features. The human approves the feature list before implementation starts, and each feature gets its own workflow, decisions, and verification.

After those features are implemented, the system checks that they work together. Independent tasks can also run in parallel using isolated Git worktrees, while conflicting tasks are kept sequential.

The idea isn't to slow down AI development. It's to gain the speed of AI agents without giving up control of the overall design.

  1. You can try it

The project is currently at v0.5.0 and is open source under the MIT license. It runs as a Claude Code plugin with a Python 3.8+ standard-library runtime.

Install it in Claude Code:

/plugin marketplace add kiduki77/human-rights

/plugin install hrs@human-rights

Initialize it in your project:

/hrs:init

Then start a task:

/hrs:new add Google authentication

Or, if you want to see whether you're actually paying attention during reviews, try:

/hrs:redpill on 5 adaptive

The repository includes an automated test suite, but this is still an early-stage project. Some integrations, including live GitHub adapter operation and real concurrent sub-agent execution, still need field validation.

GitHub: https://github.com/kiduki77/human-rights

Where this could go

Right now, human-rights focuses on individual development workflows, but I think the underlying problem could become much more important for engineering teams.

As AI generates more code, how do we know that code was meaningfully reviewed? How do we distinguish a real technical decision from a rubber-stamp approval? And how do we help developers improve at finding problems instead of gradually losing that skill?

Imagine an engineering team where AI generates most of the code. A developer approves a pull request without noticing that an important requirement was missed. Another developer catches the same issue immediately.

Today, we can track who approved a pull request, but that doesn't necessarily tell us how thoroughly it was reviewed. What if we could help developers identify the types of mistakes they tend to miss, practice reviewing realistic changes, and improve over time?

I think there's an opportunity to build something that doesn't just manage AI-generated code, but helps humans become better reviewers of it.

That's a longer-term idea, not something I'm claiming the current plugin already solves.

For now, I'm starting with the problem I experience every day: making sure I still understand and control the software I'm building.

I'd love to hear what other developers think

I'm especially curious whether other developers have noticed themselves reviewing AI-generated code less carefully over time. Would enforced approval gates help, or would they just become another form of bureaucracy? And would you actually enable something like Red Pill Mode in your own development workflow?

I don't have all the answers, and I'm sure there are things I've overlooked. That's why I'm releasing this as open source and looking for feedback from developers who are experiencing the same problems.

I built this because I don't want to stop using AI.

I just don't want to stop being a developer while using it.

human-rights — AI writes the code. Humans own the decisions.

https://github.com/kiduki77/human-rights

Top comments (21)

Collapse
 
kami_butt_69b922ade8de012 profile image
Agentic Affairs •

The L0–L3 classification is the part most "human in the loop" setups skip — treating a login-card centering and safety-critical control logic as the same review burden is why people end up rubber-stamping everything. The enforced workflow point matters too; a prompt saying "always ask" isn't a control. Do the L2/L3 plans get re-classified if the agent discovers scope creep mid-task?

Collapse
 
jaehong_kim_d5b09a9422944 profile image
jaehong kim •

Yes, and it's enforced rather than left to the agent's judgment.

Every task in an approved plan has a boundary. When the agent finds it needs to change something outside it, it files a scope change request instead of quietly continuing. Absorbing that new scope means editing the plan, and the design approval is bound to a hash of the plan, so the approval is invalidated and the state is pulled back. The human approves again before work continues.

Going back also means re-running the router. The mode can go up (L2 → L3), and it only ratchets one way for safety: a gate that was triggered by a safety flag is never released by reclassification.

There's a second outcome too. If the feature turned out to contain several results that can each be verified and shipped on their own, it stops being one feature. It's split into a group, and you approve that list before anything else is built.

So scope creep costs a round-trip to the human, which is the point: the plan you approved is the plan that gets executed.

Thank you for asking :)

Collapse
 
kami_butt_69b922ade8de012 profile image
Agentic Affairs •

The hash-bound approval is the detail that makes this real — invalidating the design approval on any scope edit closes the exact loophole most setups leave open. And the one-way ratchet on safety flags is the right call. Does the round-trip cost ever get painful on fast-moving work, or is that friction exactly the point?

Thread Thread
 
jaehong_kim_d5b09a9422944 profile image
jaehong kim •

Both, honestly. The friction is the point where it's deserved, and a bug where it isn't, so the design goal was to make it proportional rather than constant.

Every request gets graded L0–L3 before anything else. L0/L1 (center a card, rename a field) go straight to change + check with no approval at all. The design gate only applies at L2/L3, and the final gate only at L3. So fast-moving work mostly never sees a round-trip.

Where it does hurt: a mid-flight scope change on an L2/L3 feature. The hash changes, the approval drops, and the state gets pulled back to design. That's a real cost, and I've grumbled at it myself. But every time I looked at what had actually changed, it was something I'd want to have seen. The alternative is an approval that silently covers a plan I never read, which is the loophole you mentioned.

Two things keep it tolerable in practice: docs-only commits don't invalidate the final approval, and a request that's really several results gets split into separate features, so a change in one doesn't reopen the others.

The part I haven't solved is grading itself. If the tool over-grades, you pay friction for nothing, and the one-way ratchet on safety flags means it errs in that direction on purpose. I'd rather be annoyed than surprised, but I can see that trade not working for everyone.

Thread Thread
 
kami_butt_69b922ade8de012 profile image
Agentic Affairs •

Proportional friction is exactly the right design goal — the grading step is doing all the real work here, and it's the honest weak spot: a request graded too low never sees a gate at all. Is the grading rule-based, or does the model grade its own requests?

Thread Thread
 
jaehong_kim_d5b09a9422944 profile image
jaehong kim •

Split down the middle, and I know exactly what you mean, because the half that matters most is the model's.

The model does the scoring: after probing the code it gives six axes a 0–3 score (ambiguity, scope, architecture, risk, verification difficulty, dependencies) and raises flags like auth, secrets, or destructive_migration. Each score has to come with its evidence, whether it was confirmed against the code, and a confidence level.

The mapping from scores to grade is plain code, not the model: risk or architecture at 3 forces L3 on its own, any flag forces at least L2 with both gates, a safety flag forces L3, and an unconfirmed low-confidence score is bumped up by one before any of that. The model can't pick a grade, only the inputs, and it can't write the state file directly.

So your worry stands. If the model scores everything 0 with "confirmed, high confidence" and raises no flag, the rules return L0 and no gate ever appears. What exists against that today is detection, not prevention: the scores and their evidence go into a hash-chained log, so an under-grade is visible and attributable afterwards.

I don't have a finished answer for it. I use this on my own projects every day, and that's how I'm finding these holes and closing them one at a time. Under-grading is on that list, and the direction I'm leaning is a floor the model has no say in, such as paths the repo owner marks as always gated. If you have seen a setup that handles this well, I'd like to hear about it.

Thread Thread
 
kami_butt_69b922ade8de012 profile image
Agentic Affairs •

That separation — model scores, code maps — is the right call; letting the model pick its own grade would be grading its own homework. The honest bit is that under-grading is detection-only today, but the hash-chained log plus a floor of always-gated paths is a solid direction. One thing I'd add: random spot-checks on L0 decisions would make the log more than a post-mortem — a small sample that gets human-reviewed keeps the scoring honest in practice. Have you tried sampling, or is the floor the first thing you'll build?

Thread Thread
 
jaehong_kim_d5b09a9422944 profile image
jaehong kim •

Good point, thank you :). I haven't tried sampling yet, and the floor comes first. The floor is prevention: a path the owner marks as always gated can't be scored down, whatever the model says. Sampling is detection, but a better kind than what I have now.

Your point about the log being a post-mortem is fair. Right now nobody reads an L0 entry unless something has already gone wrong. A sample would change that, and it's cheap to build because each entry already holds the six scores with their evidence. Pull one in N, show the human the scores next to the actual diff, and ask one question: would you have wanted a gate here? A "yes" is a measured under-grade, which is a number I don't have today.

Two things I'd want to get right. It has to be random and not chosen by the model, for the same reason the model doesn't pick its own grade. And it has to stay small, or it brings back the constant friction the grading exists to remove. I already sample in one place: Red Pill Mode plants a flaw in about one in N approval requests to check that the human is really reading. This would be the same idea aimed at the model's scoring.

I'll think this through and work on it. If you could open an issue on the repo, I can look at it in more detail and reflect it properly: github.com/kiduki77/human-rights/issues

Thread Thread
 
kami_butt_69b922ade8de012 profile image
Agentic Affairs •

The Red Pill parallel is a good one — same mechanism, aimed at the scorer instead of the human. Random and small are the right constraints; the moment sampling is model-chosen or large, it becomes the friction it was meant to measure. Floor first, then the sample — that sequencing is right, and it's worth capturing as an issue on the repo so the design doesn't get lost.

Thread Thread
 
jaehong_kim_d5b09a9422944 profile image
jaehong kim •

Thanks, that's a clear way to put it: the sample must not become the friction it measures. I'll write this up as an issue on the repo, floor first and sampling second, so the design and the order stay on record.

If you try it and anything else looks off, please let me know. 🥰

Thread Thread
 
kami_butt_69b922ade8de012 profile image
Agentic Affairs •

Will do — I'll give the plugin a try once the floor is in and let you know what I find. Linking the issue here when it's filed would help anyone following along see the design settle. Good luck with the build.

Collapse
 
alexshev profile image
Alex Shev •

Review fatigue is often a classification problem before it is a staffing problem. The L0–L3 framing becomes powerful if the classification is tied to evidence: why this change is low risk, what can be auto-checked, and which condition promotes it to human review. That prevents “low risk” from becoming a label of convenience.

Collapse
 
izgorodin profile image
Edward Izgorodin •

Red Pill Mode measures attention only as long as the planted items look like the misses that happen for real. If the plants are mostly a number that differs from the requirement in a test table, a reviewer can learn to scan tables for numbers and catch every plant without getting better at the rest, like an assumed requirement or a change outside the scope, which are the misses you describe at the start.

One way to check that the exercise transfers is to keep, next to the plant catch rate, a count of real problems found after an approval: a bug traced back to an approved change, a requirement someone notices was dropped. If the catch rate goes up and that count does not go down, the reviewer is getting better at the game, not at the review.

Collapse
 
jaehong_kim_d5b09a9422944 profile image
jaehong kim •

You're right, and I've seen it from the inside. Using it on my own projects, the plants come out too much alike, and too many of them are the number game you describe: a value in a table that differs from the requirement. After a few drills I was catching them by scanning for numbers, which is the exact failure you predicted.

I'm fixing that now. The plants are being reworked so they come from the state of the feature itself, and are harder and more plausible: a requirement that was assumed, a change outside the scope, something left out without a word. Those are the misses that happen for real, and the drill is only worth anything if it looks like them.

Your second point I agree with completely. The tool already records defects found after final approval and results the user judged different from what they meant, but they are entered by hand and reported nowhere near the catch rate, so the comparison you describe can't be made from what it prints. Those two numbers belong side by side. With one person's usage the counts will be too small to prove transfer, but a catch rate climbing while escapes stay flat would at least be visible.

Thank you for the precise version of the criticism.

Collapse
 
izgorodin profile image
Edward Izgorodin •

The defects your tool already records after final approval, and the results you judged different from what you meant, could also decide which plants to make. The state of the feature gives a plant its content, and the records can say which kind to plant more often. Then the drill is weighted toward the misses you actually make.

Before a record counts as an escape, I would ask one thing: was the problem visible in what you were shown when you approved? A bug that appears only after a later feature is built on top of the approved one, or a need that changed after the approval, is not a review miss, and a plant made from it could not be caught in review either. No drill can lower that part of the count, and with counts this small two or three such records can hide the effect you are looking for. Since the records are entered by hand anyway, the question can be one yes or no field.

Thread Thread
 
jaehong_kim_d5b09a9422944 profile image
jaehong kim •

Both points are useful, thank you.

The yes/no field is the one I can add right away. You're right that without it the count mixes two things: what I missed in review, and what nobody could have seen at approval time. With numbers this small, the second kind would hide any effect. One question at entry, "was it visible in what you were shown?", separates them.

Weighting the plants by real misses is a good next step too. Today the tool only records the way a plant was wrong so that it doesn't repeat it. Your idea is the other half: use the escape records to say which kinds to plant more often. One thing I'd watch is that the weight stays a tilt and not a rule. If my real misses are mostly missing checks and every drill becomes a missing check, I'm back to a pattern the reviewer can learn.

I'll put both in an issue on the repo. If you try it and anything else looks off, please let me know.

Collapse
 
elarigent profile image
Elarigent •

The Red Pill Mode point is the one that sticks with me — an approval gate only works if the human is actually reading, and most systems never test that. The L0–L3 grading is what makes it workable in practice, though: asking for the same level of review on a login-card tweak as on safety-critical logic is exactly how reviewers learn to click approve without looking.

Collapse
 
jaehong_kim_d5b09a9422944 profile image
jaehong kim •

Thanks, that's exactly the pair I was going for. The two parts need each other: grading keeps the number of approval requests low enough that reading each one is realistic, and Red Pill Mode checks that the reading really happens.

The weak spot is the grading itself. If the model scores a risky change too low, nobody is asked at all. Today that is only visible afterwards in the log, so the next two things I'm building are a floor (paths the owner marks as always gated) and a small random sample of ungated changes:
github.com/kiduki77/human-rights/i...
github.com/kiduki77/human-rights/i...

If you try it and anything looks off, please let me know.

Collapse
 
robertpaschal profile image
Odinaka Robert Nnamani •

hash-bound approval is the part I'd borrow. a scope change keeping the old approval is the quiet failure. how do you keep L0-L3 from over-grading a small fix into L2?

Collapse
 
humanonmute401 profile image
Human On Mute 401 •

Ha, the bit where it mocks you for approving blind is going to land with a lot of people. Do you reckon reviewers just learn to spot the planted ones, like phishing test emails, and skim the rest?

Collapse
 
jaehong_kim_d5b09a9422944 profile image
jaehong kim •

Yes, that's the failure mode I'm designing against. Phishing tests get easy because the fakes share a look. Mine started to as well: mostly a number that didn't match the requirement, and I was catching them by scanning for numbers.

So the drill now adapts on two axes. Difficulty goes up after clean catches and down after misses. And the way a plant is wrong is recorded, so the next drills use a different one: a check that quietly went missing, an assumption nobody agreed to, a decision credited to the wrong party, a test moved to a requirement it doesn't verify. A number-only change is allowed once per set and never at the hard level.

The hard ones are a real row changed or removed, never an extra row, so nothing in the row looks odd by itself. You only find it by comparing with the requirements, which is the same work as reviewing the real rows. If there's no pattern to learn, skimming stops paying off. Whether that carries over to real misses is what I still need to measure. :)