Contact Us
Product
What is Reqode?
Reqode is a requirements-driven system for AI-assisted software development. It gives technical teams a structured product model, controlled Change Requests, MCP context for coding agents, and verification against specifications and architecture.
Built for tech leads, architects, engineering managers, and experienced AI coders who want to use AI without letting product knowledge disappear into temporary chat history. Especially on long-lived codebases.
Key Concepts
These concepts are the mental model behind Reqode. They explain how the product keeps specifications, implementation context, AI work, and reviewable change control connected.
Structured Artifacts
Reqode does not keep product knowledge as one large requirements document. It splits knowledge into focused artifacts with explicit types, states, revisions, and relations.
This makes changes easier to review, lets AI load focused context, and shows exactly which product elements are affected.
Requirement-Centric Navigation
Requirements act as the main navigation layer for product behavior. A team can start from a feature, use case, story, or rule and see related APIs, UI, data, tests, software units, issues, findings, and Change Requests.
Analysts, developers, QA, architects, and AI agents work from the same product intent instead of disconnected task lists or file trees.
Living, Branch-Aware Specifications
Specifications are working product artifacts, not static documentation. They can have branch-specific versions, revision history, lifecycle states, linked AI drafts, tests, findings, and implementation updates.
Teams can prepare planned or experimental changes without replacing the main product view too early.
Software Units
A Software Unit is a logical implementation block: a Laravel Action, API controller, React component, integration client, workflow, test suite, or another meaningful code unit in your architecture.
Each unit can describe its purpose, files, dependencies, rules, and linked specifications. This is how Reqode traces from source code back to product behavior and gives coding agents architecture-aware context.
Change Requests
Change Requests package controlled product changes. A CR-* key can include the goal, branch context, affected specifications, affected subsystems, linked AI tasks, implementation instructions, and follow-up findings.
This gives engineers and AI coding agents one stable work object instead of a loose prompt, document, and chat thread.
From idea to verified implementation
Reqode is not just a place to store specs. It is a workflow for turning product input into reviewed specifications, a controlled Change Request, focused coding-agent context, code changes, and verification results.
AI Analyst starts from product input
The user gives AI Analyst product ideas, change goals, notes, or early requirements.
AI Analyst analyzes current Reqode context: existing specifications, related artifacts, software units, and implementation context where available. When behavior is underspecified, it asks clarification questions before drafting changes.
Specifications are proposed as a reviewable change set
AI Analyst returns a structured proposal that can include updated requirements, data entities, UI behavior, transitions, wireframe notes, API operations, tests, and suggested software-unit links.
The proposal is not applied as product truth automatically. The user reviews, edits, accepts, or rejects the changes.
A Change Request captures the controlled scope
After review, the accepted specification updates become part of a Change Request.
The Change Request stores the product goal, branch context, affected spec revisions, affected subsystems, linked AI tasks and summaries, and additional implementation instructions.
The coding agent receives a CR key
The user passes a compact instruction to the preferred coding agent, for example: Use Reqode MCP and implement CR-123.
Through MCP, the agent loads focused context instead of a large copied context package:
get-change-requestfor goal, scope, affected specs, branch context, AI summaries, and instructions.get-app-manifestfor subsystem architecture and coding rules.get-artifact,get-unit, andtrace-filefor precise implementation context.
The team commits or opens a pull request
The coding agent changes the repository using the team's normal development workflow.
After a commit, pull request, repository sync, or configured review checkpoint, Reqode can analyze what changed and connect it back to the product model.
Reqode verifies implementation against specs and architecture
Reqode updates file-to-unit tracing when needed, checks implementation against linked requirements, and compares code with subsystem architecture, code manifest guidance, unit type rules, and unit-specific instructions.
Mismatches become durable Findings connected to the relevant specification, software unit, file, or Change Request.
The handoff is a key, not a context dump
The important engineering unit is the Change Request. A coding agent can start from CR-123, ask Reqode MCP for the relevant requirements, artifacts, software units, files, branch context, and coding rules, then work with a smaller and more reliable context window.
That is the practical difference between a one-time documentation read and an agent working from the current product model every time it changes code.
Use Reqode MCP before editing code. Start from CR-123. Implement the change request in the current subsystem repository. If implementation reveals missing or conflicting specs, stop and report the issue before changing behavior.
Product Areas
Use these sections to go deeper into the parts of Reqode that matter for your team: specifications, implementation context, Change Requests, MCP, AI assistants, alignment, and requirement-level tracking.
Specification Management
Manage product specifications as typed, linked, versioned artifacts instead of isolated documents.
- Tree-structured specification repositories.
- Requirements, APIs, UI, data, tests, and related artifacts in one model.
- Revision history, branch-aware work, and collaborative review.
- AI-assisted completeness, consistency, and quality analysis.
Software Units and Implementation Context
Map source files to meaningful software units, capture architecture and unit-level rules, and connect implementation back to requirements and specifications.
This layer gives architects a way to encode technical intent and gives AI coding agents the context they need before editing files.
Change Management
Use Change Requests to package product changes before implementation and keep the whole path traceable.
- Controlled work packages for feature changes and architectural changes.
- Branch context, affected artifacts, affected subsystems, and implementation instructions.
- Links to AI Analyst work, coding-agent tasks, commits, pull requests, and findings.
MCP for Coding Agents
Keep your preferred coding agent while Reqode provides structured, branch-aware product and implementation context through MCP.
The agent can load Change Requests, artifacts, units, code manifest rules, and file tracing on demand, which saves tokens and reduces context drift.
AI Assistants
Reqode AI assistants work with structured product context instead of a disconnected prompt.
AI Analyst helps turn product ideas into reviewable specification updates. Other assistants can help with architecture, APIs, data, UI, tests, code analysis, and verification workflows.
Specs to Code Alignment
Verify that implementation still matches linked requirements and architecture context.
Reqode can detect drift, create findings, and help the team decide whether the next change belongs in code, specifications, unit mapping, or architecture guidance.
Requirements Tracking
Track product work at requirement level: status, related specs, implementation units, tests, warnings, issues, findings, and Change Requests.
This gives technical managers and leads a functional view of progress and risk without losing the engineering detail underneath.
Start with one controlled change
Reqode does not require a perfect model on day one. Start with one product area, let AI Analyst prepare a reviewable specification update, create a Change Request, hand the CR-* key to your coding agent, and verify the result.