Get Early Access
info@reqode.com
© Almware ltd.

Contact Us

Contact us if you have any questions, suggestions or you need personal Demo of Reqode. Use the form or write us a letter.
Use Cases

Preventing Architecture Drift

Keep AI-generated and human-written code inside the intended architecture: map files into software units, verify units against subsystem rules and guidelines, and turn confirmed violations into actionable Findings.
Get Early Access
Get Early Access

Architecture Drift Is a Control Loop Problem

Code can still work while the architecture is already drifting. Reqode makes the expected structure explicit, maps the real implementation, verifies units, and routes confirmed violations into work.

1

Layer drift

Controllers start owning business logic, services become hidden use cases, models hide side effects, or queries write data.

Verifier checks Code Manifest and Unit Type rules.
Finding routes the fix to code or architecture work.
2

Ownership drift

A unit absorbs behavior that belongs elsewhere, new files are not mapped, or a unit links to specs it does not own.

Unit Discovery updates file ownership and dependencies.
Unit architects can repair relations and boundaries.
3

Pattern drift

A feature bypasses a required implementation pattern, UI/UX consistency, API conventions, etc.

Patterns keep repeated decisions visible.
Findings show the expected approach and actual violation.

What Reqode Uses as the Architecture Contract

Reqode does not rely on one giant AI prompt. It stores architecture context as project artifacts that humans can review and AI agents can read.

Code Manifest

Subsystem-wide rules for stack, folders, request flow, dependency direction, side effects, testing, and instructions for AI coding agents.

Unit Types

Role-specific guidance for controllers, actions, services, queries, models, jobs, integration clients, frontend components, and tests.

Software Units

Logical implementation areas connected to files, dependencies, consumers, guidelines, specifications, verification state, and Findings.

Implementation Patterns

Reusable implementation approaches linked to Unit Types, requirements, examples, and actual Software Units where the pattern is applied.
Verified Architecture Rules

From written guidance to enforceable feedback

The same rules that guide developers and AI agents are used by Unit Guidelines Verifier. If a change breaks the expected architecture, the result is visible on the unit and in the Findings queue.

Subsystem Code Manifest defines the broad contract.
Unit Type rules define role-specific behavior.
Unit-specific guidelines protect local ownership boundaries.
Implementation Patterns capture repeated architecture decisions.
Architect Verification Loop

Findings Turn Drift into Work

Reqode does not stop at "something looks wrong." A Finding stores evidence, severity, affected artifacts, and solution actions that point to the right performer.

Fix code

The architecture rule is valid and implementation violates it. Send the Finding, Unit, manifest, Unit Type, guidelines, and files to a coding assistant.

Performer: AI Coding Agent
Handoff: FINDING-*

Fix unit metadata

The map is stale: files, dependencies, consumers, unit-specific guidelines, or Unit-Spec relations need correction before code is judged.

Performer: Unit Discovery Agent
Handoff: unit map and dependency context

Fix architecture rules

The code is intentional, but the Code Manifest or Unit Type rules are outdated. Route the change through architecture review.

Performer: AI Architect
Handoff: manifest or Unit Type change

Decide intent

The verifier found a real conflict, but the team must decide whether product behavior, architecture guidance, or implementation should change.

Performer: Manager
Handoff: evidence and options
Finding detail
Coding Assistant Handoff

Give the assistant a Finding, not a vague cleanup task

The coding assistant can start from the concrete architecture violation and read Reqode MCP context before editing files.

That context includes the target Unit, source files, Code Manifest, Unit Type rules, unit-specific guidelines, dependencies, and Finding evidence.

Example Prompt

Start repair from verified evidence

A good coding prompt can be short because Reqode provides the architecture context. 

Use Reqode MCP as a source of truth.
Start from FINDING-123 and U-456.

Automate Discovery and Verification After Changes

Configure AI Automations per branch and subsystem so changed files and unverified units do not wait for a manual audit.

1

Units Discovery

Processes files with unknown unit sync state and updates units, file assignments, dependencies, ignored files, and Unit-Spec links after backend validation.

  • Project Branch
  • Subsystem
  • Max checks per run
  • Max files per check
2

Unit Guidelines Compliance Check

Runs Unit Guidelines Verifier for units that need verification, updates the unit status/result/date, and creates or solves guideline Findings.

  • Project Branch
  • Subsystem
  • Additional prompt
  • Max checks per run
3

Specs - Code Alignment Check

Runs Unit Alignment Verifier when responsibility drift may also affect requirements, data entities, user interfaces, or API operations.

  • Project Branch
  • Subsystem
  • Model and run mode
  • Max checks per run
Dashboard

See the local Finding and the system-level picture

The current Project Dashboard can show subsystem-level quality groups, including Code Guidelines Findings, Unit-Spec Alignment Findings, Specification Inconsistency Findings, and Security Findings.

A broader architecture dashboard is coming soon. It can show verification coverage, stale units, unlinked files, Unit Types with recurring Findings, and drift trend after recent changes.

Project quality signals

Keep code inside the architecture you chose

Reqode makes architecture rules visible to humans, available to AI agents, and verifiable after changes. Drift becomes evidence, Findings, repair work, and a new verification run.

Get Early Access