Frequently Asked Questions

Ninchi is a developer tool that integrates with GitHub and asks simple questions about pull requests to verify that the person submitting the code understands what it does.

It's designed for an era where AI tools make it easy to generate code quickly — sometimes faster than we can fully reason about it.

For the individual developer, Ninchi creates a useful accountability record — confidence that you genuinely understand the code you ship.

For teams, Ninchi creates a unique business insight: managers can identify knowledge silos, track where domain expertise lives across the team, and build confidence in code ownership.

Ninchi encourages conscientious development practices and helps build a verified record of real human expertise — something no other tool provides.

I was getting concerned about how quickly I was creating software without fully understanding it. AI tools made it incredibly easy to move fast, but I found myself occasionally submitting code where my understanding wasn't as strong as I would have liked.

Ninchi started as a way to ensure I had a firm grip on what I was building — and to bring that same level of accountability and clarity into team workflows.

No.

Ninchi is not designed to monitor, rank, or punish developers. It focuses on understanding code changes, not evaluating people.

Teams can choose how they use it:

• Casual mode → learning and curiosity, no scoring
• Tracking mode → insight into knowledge distribution
• Blocking mode → optional enforcement before merge

The goal is to improve clarity and knowledge sharing, not to create pressure or surveillance.

Code review checks whether the code is correct.

Ninchi checks whether the author understands the code.

These are related, but not the same. In AI-assisted workflows, it's increasingly possible to submit code that “works” without fully understanding why. Ninchi adds a lightweight check at that point.

Sure, people could ask another LLM for the answer, but no verification tool is infallible. Ninchi has some configurable anti-cheat features but the overall goal is not to make it impossible for people to submit work they don't understand but just less convenient.

Besides, even if users cheat, the process of getting an answer will cause them to learn something meaningful about their work they didn't know before, a net positive. Mass adoption of Ninchi, even if many people cheat, will result in humans understanding their technology far more than they would otherwise.

Possibly. It depends on team culture and how it is used. Ninchi can be run in non-blocking mode with easy questions that users can quickly answer and merge their code regardless of result.

Or Ninchi can be run on more strict settings potentially slowing down PR merges as developers fail to demonstrate an understanding of their work. Teams have to decide if they are comfortable with this tradeoff — potentially slower development but greater engineer accountability and ownership.

AI-assisted coding has changed the cost structure of development:

• Writing code is cheaper
• Understanding code is more expensive

Ninchi focuses on the second part — ensuring that human understanding keeps up with AI-generated output.

No.

Ninchi is designed to be code-aware, not code-retentive. Code is processed transiently to generate questions. Raw source code is not stored long-term. Only derived data (questions, answers, metadata) is retained.

You can read more on our Data Handling & Security page.

No. We do not train models on customer code and we do not share code across organizations.

We store only what's needed to provide the service:

• Questions and answers
• Evaluation results
• Metadata (e.g. language, difficulty, category)

We do not store full repositories or long-term copies of code changes.

Ninchi is most useful for:

• Teams using AI coding tools heavily
• Larger or distributed teams
• Codebases where ownership and understanding matter

Smaller teams may find it less necessary.

The Ninchi Score is an experimental metric representing the level of verified understanding behind code changes. It's meant to reflect how well a team understands what it ships, not to grade individuals.

No. Ninchi is not a replacement for developers or code review. It's a complementary tool that adds a layer of human accountability and explanation.

No — and that's true of any test or verification tool. Whether it's code coverage, integration tests, performance tests, or security scans, all such tools create useful data points and build confidence, not ironclad guarantees.

Ninchi is no different. It creates a useful record of demonstrable knowledge. It does not read minds or guarantee any specific outcome for developers.

For some teams, yes. For others — especially those relying heavily on AI — it can be a useful way to maintain clarity and confidence in what's being shipped.

Ninchi explores a simple idea:

In an age where AI helps create more of our work, humans should still understand and stand behind it.

Today that applies to code. Over time, it could apply more broadly to other types of AI-assisted work.

Install Ninchi on your GitHub repository and open a pull request. That's it.