How Inkspect works

A diff is only
the beginning.

Find the context. Follow the question. Bring back a finding worth your attention.

01Read the change
The diff and its intent
02Gather context
Related code and rules
03Search deeper
The questions that remain
04Explain the finding
Evidence and a next step

Context has
more than one source.

Some connections are ready to retrieve. Others emerge as the review asks better questions. Inkspect uses both.

RAG

Start with relevant context.

Retrieval-augmented generation brings related code, tests, and selected team documentation into the review. Semantic matches and exact names help find useful starting points.

Related ruleInvoice access policy

Related functionassertWorkspaceMember

Related testsWorkspace access cases

The change arrives with context behind it.

Dynamic search

Follow what needs an answer.

As questions emerge, Inkspect reads the relevant files, looks up symbols, and follows their references. The next search is guided by what the review still needs to understand.

Where is this handler called?getInvoice
What does the middleware check?requireSession
Where should access be enforced?invoice.workspaceId

Each question gives the next search a purpose.

See the context
change the review.

A new invoice endpoint looks straightforward. Follow the review to see why the surrounding code matters.

A closer look at one pull requestExample review

The pull request

Start with what changed.

A new endpoint returns an invoice by its ID. Inkspect starts with the diff and the surrounding function to understand the behavior being introduced.

Who is allowed to read this invoice?

src/api/invoices.tsNew handler

1export async function getInvoice(req) {
2  const id = req.params.id;
3  const invoice = await db.invoice.findUnique({
4    where: { id },
5  });
6  if (!invoice) throw new NotFoundError();
7  return invoice;
8}

Pull request diffThe new invoice lookup
Surrounding functionInputs, query, and return path

RAG / indexed context

Find the rule behind the code.

Retrieval brings in relevant code and team documentation. Here, the access policy supplies the missing requirement: an invoice belongs to a workspace, and reading it requires membership.

Where is workspace membership checked?

docs/access-policy.mdRelevant project context

1# Invoice access
2 
3Every invoice belongs to a workspace.
4Only members of that workspace may read it.
5 
6A signed-in session identifies the user.
7It does not grant access to every workspace.
8Check membership before returning an invoice.

docs/access-policy.mdThe workspace access rule
src/auth/membership.tsAn existing membership helper

Dynamic search / follow the question

Check how the route is reached.

The next search follows the handler to its route and middleware. The route checks for a signed-in user. Reading that middleware confirms that it does not check workspace membership.

The session is checked. The workspace is not.

src/api/router.tsHandler reference and middleware

1// Route for the new invoice handler
2router.get("/invoices/:id", requireSession, getInvoice);
3 
4function requireSession(req, res, next) {
5  if (!req.session) throw new UnauthorizedError();
6  return next();
7}
8

getInvoiceSearch exact symbol references
requireSessionRead the actual access check

A finding grounded in evidence

Make the missing check clear.

The finding connects the changed query, the access policy, and the route. It explains the consequence and suggests a concrete check for the team to review.

Your team reviews the suggestion and decides what ships.

Review commentsrc/api/invoices.ts · line 4

1Check workspace membership before returning the invoice.
2 
3This query accepts an invoice ID without checking
4whether the signed-in user belongs to its workspace.
5The route checks the session, but not membership.
6 
7Validate access to invoice.workspaceId before returning
8the record, and add a cross-workspace access test.

src/api/invoices.ts:4Lookup by ID
docs/access-policy.md:4Membership requirement
src/api/router.ts:5Session-only middleware

Illustrative walkthrough using prepared code and findings.

A closer look.
Within clear boundaries.

The right revision: Findings are tied to the code being reviewed. Retrieved snippets are checked against that revision.
The right scope: Repository access defines where a review can look. Your team chooses the repositories it connects.
An honest conclusion: A finding should explain its evidence. When context is missing or review scope is limited, that limitation belongs in the result.

Context for your whole team

One codebase.
Human and AI teammates.

Help a new teammate find their way around the project. Give an AI assistant the context behind its next task. Both use the same retrieval layer.

Ask the codebase. Learn the project.

A new developer joins your team and opens the dashboard. They can ask how authentication works, where a feature lives, or why a module behaves a certain way. RAG retrieves relevant code and documentation to ground each answer in the project.

Dashboard conversation · illustrative example

Where should I check workspace access for an invoice?

Check workspace membership before returning the invoice. A signed-in session alone does not grant access to its workspace.

Retrieved contextdocs/access-policy.mdsrc/auth/membership.ts

A starting point for onboarding, with source references to explore.

Pull context into your AI workflow.

Describe the task to the CLI context pull tool. Retrieve the relevant code, conventions, and documentation, then pass that context to your AI assistant alongside the prompt. The assistant gets a focused starting point without loading the whole codebase into every prompt.

CLI context pull · illustrative workflow

Your task: Add a workspace access check to invoice reads.
Retrieved context: Invoice handler, membership helper, access policy.
AI handoff: Your prompt + relevant snippets + source references.

The same project knowledge, ready for an AI teammate.

Retrieval stays within repository permissions. Missing context should be made explicit; indexing and targeted follow-up reads may still be needed.

Explore team context

A little more
about the process.

Can a new teammate learn the project by asking questions?

Yes. The dashboard lets your team talk to the codebase. A teammate asks a question about the codebase, and RAG retrieves relevant code and documentation to ground the answer, with source references they can explore. Answers should explain when the retrieved context is incomplete instead of guessing.

How does CLI context pull help my AI assistant?

The CLI takes a task description and retrieves relevant project context to pass alongside your AI prompt. This avoids putting the whole repository into every prompt. The repository still needs indexing, and an assistant may need targeted follow-up reads.

Why use both RAG and dynamic search?

RAG gives the review a relevant starting point from indexed code and documentation. Dynamic search follows questions that emerge during the review, using exact symbols, file reads, references, and tests. The two approaches work together to build the context behind a finding.

Does dynamic search mean searching the web?

Here, it means exploring the connected repository as the review progresses. A question about a function can lead to its callers, middleware, or tests. It is targeted code search within the review’s permitted scope.

What happens when the code changes during a review?

The review is tied to a specific revision. Retrieved context is checked against that revision before it supports a finding. A new commit is a new review scope, so findings from an older revision should not be presented as a review of the new code.

Does Inkspect apply the fix or merge the pull request?

Inkspect explains the finding and suggests a next step. Your team evaluates the suggestion, runs its checks, and decides what to apply and merge. A recommendation to add a test does not mean that test has already been run.

The context is clearer.
The call is still yours.

Use Inkspect Cloud or run it on your own infrastructure.

Start with Cloud Explore self-hosting

A diff is only
the beginning.

Context has
more than one source.

Start with relevant context.

Follow what needs an answer.

See the context
change the review.

Start with what changed.

Find the rule behind the code.

Check how the route is reached.

Make the missing check clear.

A closer look.
Within clear boundaries.

One codebase.
Human and AI teammates.

Ask the codebase. Learn the project.

Pull context into your AI workflow.

A little more
about the process.

The context is clearer.
The call is still yours.

Ask Inkspect

Curious about Inkspect?

Context hasmore than one source.

Start with relevant context.

Follow what needs an answer.

See the contextchange the review.

Start with what changed.

A closer look.Within clear boundaries.

One codebase.Human and AI teammates.

Ask the codebase. Learn the project.

Pull context into your AI workflow.

A little moreabout the process.

The context is clearer.The call is still yours.

Context has
more than one source.

See the context
change the review.

A closer look.
Within clear boundaries.

One codebase.
Human and AI teammates.

A little more
about the process.

The context is clearer.
The call is still yours.