AI code review catches mistakes after the PR is opened.
Tenure prevents them before the PR exists.
Most AI code review tools assume the problem happens at review time. Tenure assumes it happens earlier: at generation time.
Review the PR after it's opened
The PR opens with naming inconsistencies, wrong folder placement, an abstraction your team already has, and error handling that doesn't match your patterns. A bot flags some of it. The reviewer flags the rest. The author fixes, pushes again. Cycle repeats.
Align the code before the PR exists
Your team's naming conventions, folder structure, existing abstractions, error handling style, and testing expectations are in context when the code is generated. The PR opens closer to how your team would have written it. Less to debate. Fewer round-trips.
The comments that slow review cycles aren't logic bugs. They're convention violations. Things that should have been obvious from context but weren't, because the AI generating the code didn't have that context.
Your team uses getUser not fetchUser. handleError not onError. Service files are *.service.ts, not *Service.ts. Tenure stores this. Every AI request that touches these files gets it injected automatically.
Auth logic belongs in /services/auth/, not /utils/. Shared hooks go in /hooks/shared/. Tenure tracks where things live so AI stops generating files in the wrong place.
You already have a withRetry wrapper. You already have a parseApiError utility. Reviewers spend time pointing this out. Tenure stores it once. AI uses it every time.
Factory functions over classes. Repository pattern for data access. No direct DB calls from route handlers. These decisions were made in a planning doc two months ago. Tenure remembers them.
Your team throws structured errors with { code, message, context }. Always. Not bare strings, not generic Error objects. Tenure knows. The AI you're using knows, because Tenure tells it.
Vitest, not Jest. Unit tests in __tests__/ adjacent to the module. Integration tests in /tests/integration/. Mocks using vi.mock(), never manual stubs. All stored. All injected.
You don't configure rules or maintain a linting config for Tenure. You capture decisions as they happen, in the same chat sessions where you already work. Tenure extracts them, stores them locally, and injects the right ones on every AI request, before the prompt reaches the model.
When you tell your AI "we use factory functions, not classes" or "don't use Mongoose, raw driver only", Tenure extracts that belief from the conversation. No extra step. It just works in the background.
The MongoDB convention for your API project doesn't bleed into your data pipeline project. Tenure scopes beliefs to workspaces, so every project gets exactly the context it needs. Nothing more.
Before the request reaches the model, Tenure injects the relevant beliefs automatically. The AI generating your code already knows your team's patterns, so PRs arrive closer to correct.
Same AI tool. Same task. Different outcome when the AI has your conventions in context.
They sit at the end of the pipeline, after the code exists, after the PR is open, after the review clock has started. They're useful. But they're reactive.
Tenure sits at generation time, before the code is written. The reduction in PR review time is a consequence of better-aligned output, not a bolt-on review step.
PR review time becomes a consequence of better code generation.
When one engineer captures "we use Zod for input validation, not Joi", every other engineer's AI knows it too. Conventions propagate through the team without a style guide meeting, without a Confluence page nobody reads, without a linting rule that fires after the fact.
Monorepo structure, layer boundaries, forbidden patterns, approved libraries. Stored once. Injected for every engineer on the project.
Function prefixes, file naming, event naming, prop naming. The kind of thing that lives in a Notion doc nobody opens. Now it's in context automatically.
The utilities, hooks, and services that already exist. AI stops reinventing them and starts using them because Tenure tells it they're there.
"We evaluated Prisma and ruled it out." That decision lives in Tenure too. Not just what you chose, but what you rejected and why.
Free, open source, fully local. Works with VS Code, Cursor, Windsurf, Continue, Cline, and any OpenAI-compatible client.
Helm chart · OIDC / SCIM · MIT licensed · No call-home telemetry
fetchUser→getUserper our conventions.{ code, message, context }shape. SeeAppErrorin/lib/errors.