Vibe Coding

Vibe Coding Architectural Drift: Verify the Build Against Its Plan

Fast code is not complete software until its behavior can be checked against an explicit plan.

· 11 min read · Sage 7 Engineering

Fast code is not complete software until its behavior can be checked against an explicit plan.

1. The real-world failure: a convincing build can still be incomplete

Vibe coding architectural drift is not simply code that looks messy. It is the widening gap between what a product is supposed to do and what its implementation actually does. A polished interface can conceal missing permissions, incomplete error handling, unimplemented background work, or assumptions about data persistence that were never made explicit.

This is a problem of AI software completeness, not just code quality. A feature can compile and pass its available tests while still omitting a user journey, an administrative control, or a failure path that matters to the product. Conversely, a project can include substantial code whose intended behavior is unclear. Without a shared reference, neither “it built” nor “the tests passed” answers the question: built against what?

The distinction matters because conventional development artifacts answer different questions:

ArtifactWhat it can establishWhat it does not establish by itself
Prompt or conversationWhat someone asked for at a moment in timeA complete, stable product specification
Source codeWhat has been implemented in filesWhether the implementation covers the intended product
Test suiteWhether selected assertions passWhether the assertions cover all required features
DeploymentWhether software is available at a URLWhether required behavior is present or correct
Blueprint plus auditWhat the project is supposed to be, and evidence assessed against that recordA guarantee that every behavior is correct in every runtime condition

The last row describes the central distinction in spec-driven development: the specification is not a substitute for implementation or testing. It is a reference against which implementation evidence can be assessed.

Sage 7 is a Blueprint Engineering and Audit platform for AI-built software, operated by Sage 7 Enterprises (a Digital Fusion Labs company). It is not a coding agent, autonomous developer, or code generator. Inspectors and coding agents write code; Sage 7 records what the software is supposed to be and checks the build against that record.

That division of responsibility is important. A coding agent can produce a plausible implementation without proving that the product plan was complete or that all planned features were delivered. A blueprint can make intended scope inspectable; an audit can make claims about delivery traceable to evidence.

2. The underlying architectural mechanism: plans need structure

Unstructured product intent is difficult to audit. Requirements scattered across prompts, issue comments, and design files can be ambiguous, duplicated, or absent. When a build changes, there may be no dependable way to determine whether the change implements a requirement, conflicts with one, or simply falls outside the agreed scope.

A spec-driven process makes intended behavior explicit before treating code as evidence of completion. The key is not to turn every idea into a rigid contract. It is to expose decisions that otherwise remain invisible: failures, permissions, dependencies, persisted data, and operational surfaces.

Sage 7’s Blueprint begins with a Discovery interview, then creates a taxonomy map, Tech Spec, Design System, Deliverables, and Agent Context. Discovery asks pointed questions about failures, permissions, and dependencies. The taxonomy map divides product scope into 14 categories:

CodeCategoryScope represented
NAVNavigation & IAMenus, tabs, sidebars, breadcrumbs, search, deep links
ONBOnboardingFirst-run flow, coach-marks, tooltips, empty states, sample data
CORCore WorkflowsPrimary user journeys
ACTActions & ControlsButtons, forms, bulk actions, undo and confirmation patterns
FBKFeedback SystemsNotifications, loading, error, success, and progress states
SETSettings & PreferencesAccount, notifications, privacy, billing, team and roles
HLPHelp & SupportHelp center, contextual help, chat or ticketing, changelog
DATData & StatePersistence, caching, sync, and offline behavior
PRMPermissions & RolesWho can see or do what; admin and user surfaces
INTIntegrations & DependenciesThird-party services, APIs, webhooks, failure impact
ADMAdmin / Back-officeOperational screens not intended for ordinary users
SECSecurity & ComplianceAuthentication, data protection, audit logs, regulation
GRWGrowth & RetentionInvites, referrals, re-engagement, analytics events
BGDTask / Background SystemsTask bars, queues, scheduled jobs, batch processing

This map addresses a common source of architectural drift: teams focus on the visible happy path and fail to account for the rest of the product. A taxonomy does not prove that every category applies, nor does it automatically make a requirement correct. It gives the team a structured way to discover and record what applies.

The Tech Spec translates feature signals and a build profile into an ISO/IEC 25010:2023 utility tree, an OWASP ASVS level, and one recommended stack per layer. Stack recommendations are chosen by code from a versioned catalogue with Technology Radar rings. These are structured recommendations and quality targets, not certifications or proof that an implementation meets a standard.

The mechanism can be summarized as:

  1. Record intended scope. Ask about workflows, permissions, dependencies, and failure behavior.
  2. Organize it. Map features into a shared taxonomy and produce the project blueprint.
  3. Make quality intent legible. Relate feature signals and build profile to quality attributes and security requirements.
  4. Assess the artifact. Compare a GitHub repository or deployed URL against that project’s own blueprint.
  5. Retain the assessment. Seal audits into an append-only SHA-256 hash chain.

Each step constrains a different kind of ambiguity. None makes the software infallible.

3. Concrete system architecture and evidence walkthrough

A useful completeness system must distinguish requirement, implementation evidence, and confidence in that evidence. Sage 7 uses four audit verdicts: built, partial, missing, and unverified. Every built or partial verdict must cite a real file or route verified by code.

That rule is consequential. A claim without a verified file or route cannot be reported as built or partial. But evidence of a file or route does not, by itself, demonstrate that all runtime behavior is correct. The verdict should be read as an assessment against the blueprint, not as a universal guarantee of quality.

An illustrative evidence record might be represented conceptually as follows. This is pseudocode, not a Sage 7 response schema or real audit result:

text
Feature: [blueprint feature identifier]Verdict: partialEvidence:  - [repository file or deployed route verified by code]Unverified:  - [acceptance condition not established by the available evidence]

The placeholders are deliberate: a real evidence claim requires a real project and a verified file or route. Inventing a plausible path would undermine the point of auditability.

The assessment becomes more useful when the blueprint describes acceptance conditions with enough specificity to test or inspect. For example, “users can manage projects” is weak as an audit target: it does not identify who can manage what, what happens on failure, or whether the action persists. A stronger specification distinguishes the actor, permitted action, expected state change, and relevant failure behavior. The exact criteria depend on the project; they should not be guessed by the auditor.

Evidence lifecycle

StageRecord or operationEngineering purpose
BlueprintDiscovery, taxonomy map, Tech Spec, Design System, deliverables, Agent ContextEstablishes the project-specific reference
AuditRepository or deployed URL assessed against that blueprintSeparates planned scope from observed evidence
VerdictBuilt, partial, missing, or unverifiedMakes completeness status explicit
EvidenceVerified file or route for built and partial verdictsMakes those claims inspectable
SealAppend-only SHA-256 hash chainPreserves an ordered audit record
MonitoringGitHub push webhook verified by HMAC; files classified by pathTriggers reassessment of touched features

The chain and the audit answer related but different questions. A SHA-256 hash chain can make changes to the recorded sequence detectable; it does not prove that the underlying assessment is correct. HMAC verification authenticates push webhooks; it does not establish that a code change is secure or complete. Those boundaries are necessary for a credible evidence model.

For paid plans, Sage 7 can connect to GitHub. Push changes are classified by file path with zero AI cost, and push audits reassess touched features. Sage CTO auto-confirms high-confidence verified code. These capabilities reduce the need to treat every repository change as a full re-evaluation, but path classification is not a substitute for semantic understanding of every change. The audit still needs to be interpreted in the context of the project’s blueprint and its evidence.

Quality attributes are not interchangeable

ISO/IEC 25010:2023 provides a product-quality framing; OWASP ASVS provides a security verification standard. Using such references can help make quality intent explicit, but a named framework is not evidence of conformance. The audit should avoid collapsing distinct questions into a single “quality” label.

ConcernBlueprint questionWhat an audit can contribute
MaintainabilityIs the expected structure or technology approach recorded?Evidence that relevant files or routes exist; not a complete maintainability review
ReliabilityWhat should happen when a dependency or workflow fails?A check against recorded failure-related requirements; not proof of behavior under every condition
SecurityWhich roles, protections, and controls are required?Evidence assessed against the project’s recorded requirements and security framing; not certification
CompletenessWhich planned features have evidence?Per-feature verdicts tied to the project’s own blueprint
TraceabilityWhat changed and what was assessed?A sealed audit sequence and, for GitHub monitoring, change-triggered reassessment

The discipline is to state what evidence supports and what remains unverified. A missing result is not the same as a failed result; an unverified result is not a pass. In particular, a code verification gap arises when a team treats the presence of a plausible implementation as proof that a requirement is satisfied, without checking the requirement or its evidence.

Context is a separate engineering problem

An agent working from an extensive blueprint needs relevant context without receiving an unbounded document. Sage 7’s Context Compiler rebuilds living context deterministically from database rows, uses a light-model summary, and versions snapshots in context_snapshots. It minifies compiled context.md, scores it with BM25 against the next task, and selects content under 2,500 tokens using greedy budgeted submodular maximisation.

This is context selection, not a change to the source of truth. The blueprint remains the project record; the compiled context is a task-oriented view. A coding agent using Sage 7’s read-only MCP server can retrieve project, feature, and context information. The server exposes https://sage7.dev/mcp, with a limit of 60 requests per minute. For a new session, an agent first lists projects when the project ID is unknown; when asked to start the next feature, it retrieves one approved next task, then that feature’s full specification before planning. The workflow is intentionally scoped to one feature at a time.

This model supports a clean handoff: the specification and evidence inform implementation, while the agent remains responsible for writing code. If the specification leaves a blocking question unanswered, the agent can report it to the owner rather than silently decide. Decisions outside the specification can also be reported for owner confirmation. Once a feature is finished, progress can be reported with commits and files; the feature awaits audit, and only an audit marks it built.

4. Engineering trade-offs and operational costs

A structured blueprint adds work before implementation. Its value depends on whether that work surfaces consequential requirements early enough to matter. The alternative—leaving assumptions implicit—also has a cost, but it is harder to measure because omissions may only become visible during integration, deployment, or later changes.

ApproachStrengthCost or limitation
Prompt-led, unstructured buildFlexible and low-friction at the startIntent may be fragmented; omissions are difficult to assess systematically
Tests without a project blueprintVerifies selected assertionsCoverage is bounded by the assertions and does not establish full product scope
Blueprint plus evidence auditMakes intended scope and per-feature evidence comparableRequires Discovery, blueprint maintenance, and interpretation of audit results
Push-triggered reassessmentConnects repository changes to touched featuresDepends on GitHub integration and path-based classification; does not make every code change self-explanatory

The right level of specification is a trade-off. Over-specification can freeze decisions that should remain open; under-specification lets implementation choices masquerade as product requirements. A taxonomy helps identify the relevant surfaces, while Discovery questions expose ambiguity. Neither replaces engineering judgment about how much detail a feature needs.

There is also an explicit metering model. The following are credit amounts per listed operation, not estimates of elapsed time, quality, or monetary cost per task:

OperationCredits
Blueprint10
URL audit20
Repository audit25
Push audit5
Compliance assessment15
Context2
Design System8

Plans allocate different monthly credit and project limits: Founder provides 80 credits and 3 projects for $19; Builder provides 250 credits and 8 projects for $49; Studio provides 700 credits and 20 projects for $129. Free includes one project and a read-only blueprint preview. These figures describe the published plans, not the total cost of operating a team’s development process. Additional credit packs are also available, but whether a particular plan is economical depends on actual usage.

AI routing is separate from the deterministic parts of the workflow. Experiential Labs is the default, with OpenRouter, RadoxAI, Groq, NVIDIA NIM, and Cloudflare Workers AI as fallbacks. Service states are Ready, Degraded, or Unavailable, and cost is tracked per actual model. The claim that push file classification has zero AI cost should not be generalized to every AI-assisted component: the context compiler, for example, uses a light-model summary.

The operational trade-off is therefore not “deterministic system versus AI.” It is to make the record, selection, evidence requirements, and audit history explicit while identifying where model-dependent work remains. Teams should evaluate the resulting workflow against their own verification needs rather than assume that a blueprint or an audit eliminates review.

What this does not claim

Sage 7 does not write the application code. Inspectors and coding agents do that. It records what the software is supposed to be and checks a build against that record.

A built verdict is not a guarantee that every execution path is correct, secure, reliable, or maintainable. A verified file or route is required evidence for a built or partial verdict, but evidence still has a scope. The append-only SHA-256 hash chain preserves an audit record; it does not make an incorrect assessment correct. A framework reference is not a certification, and an OWASP ASVS level is not proof that a project satisfies every applicable security obligation.

No published benchmark edition or result numbers exist yet. Sage 7’s planned twice-yearly benchmark report is to be computed from consenting projects, not surveys. Its defined measures include first-audit completeness, category miss rate, verification gap, 90-day recovery, regression rate, and plan size. Each headline cell requires at least 25 consenting projects; otherwise it reads “not enough projects.” The report will not rank tools as best or worst, and it will not count unverified features as missing or passed.

Accordingly, this essay makes no performance comparison, speed claim, customer claim, or benchmark claim. The useful claim is narrower and testable: when a project has an explicit blueprint, an audit can assess its build against that project-specific record and attach real file or route evidence to built and partial verdicts. That is a more disciplined way to discuss AI software completeness than treating a convincing demonstration as proof of a complete product.

Audit your codebase with Sage 7 before your coding agent drifts

Run a free Quick Audit on a public repo or URL, or start Free Discovery to turn your idea into a verified blueprint.