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 (3)

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?