Agentic software engineering across the entire SDLC
SPECTRA implements fully agentic workflows across the entire SDLC — turning product intent into working software through a disciplined, human-gated loop where AI agents do the heavy lifting and engineering team approves each phase as it goes. Standards encoded once, impact measured end-to-end, delivered with hands-on enablement.
Vibe coding and plan mode — Claude Code, Cursor, and the rest — supercharge a single phase. But each phase runs in its own session: the agent rebuilds its understanding from scratch every time, and the spec, design, tests, and code drift apart at every hand-off. That's AI-assisted — a faster typist. True AI-native engineering keeps one context intact across the whole lifecycle, so every phase builds on the last instead of starting cold.
SPECTRA makes the whole lifecycle agentic, not just the coding step. In every phase, purpose-built agents take on the work that needs interpretation — turning a business ask into requirements, requirements into a design, a design into tasks, code, and tests, and a finished change into a reviewed pull request. Every one of them reads and writes one shared, durable context, so the spec, plan, design, tasks, and code stay in lockstep instead of drifting apart at each hand-off, and every agent stays inside the standards and guardrails set for the system. A human owns the gate at every step. Continuity is the design goal; speed and quality follow from it.
SPECTRA is built on GitHub Spec Kit — the open-source toolkit that brings spec-driven development to AI coding agents. That methodology is a proven discipline for turning intent into working software, and it complements AI exceptionally well.
On that foundation, SPECTRA adds its multi-agent orchestration layer — the layers that make it enterprise-grade.
Instead of one generalist doing everything, SPECTRA comes with a roster of agents — each optimized for a single job and primed with the project’s standards.
Every SPECTRA roster is built from two kinds of agents — a required core that runs the SDLC end-to-end, plus optional add-ons you switch on as the domain demands.
The backbone of every SPECTRA implementation. Core agents run the spec-driven SDLC end-to-end — requirements, architecture, implementation, testing, and deployment. Every engagement ships with the full core roster.
Optional specialists you switch on as the work demands — they audit, validate, and add more to the context. Compliance, privacy, security, and quality checks layered onto the core flow; pick only the ones your project needs.
Every step of the Spec Kit loop has an owner. Agents draft; these roles drive each step and approve what it produces.
Sets the design principles and development standards once — every step below inherits them.
Captures the what and the why: user needs and functional requirements, written as the spec.
Resolves the ambiguities before they become rework, keeping the spec, plan, and tasks aligned.
Decides the how — frameworks, libraries, data stores, infrastructure — and delivers a technical plan with research and a quick-start.
Breaks the technical plan into clear, actionable tasks that can be executed and traced.
Checks the spec and plan against each other and against the standards, finding gaps and suggesting improvements.
Builds from the defined tasks and plan, so work runs in parallel and progress stays predictable.
Agentic, not autonomous. Agents take the work that needs interpretation, deterministic automation keeps the work that doesn’t, and people keep every decision that matters. That division is what lets a team move at agent speed without handing over control.
SPECTRA layers on top of the coding agent a team already runs — Claude Code, as an example — rather than beside it. Working inside that agent means working through the same harness: the same shell, the same CLIs, the same repositories, build systems, and internal services the developer already has on their machine. That is what lets a SPECTRA agent do the engineering work instead of only describing it — it operates at exactly the level of access its user has, and no further. Control is inherited the same way: every action passes through the host agent’s permission model and whatever policies, approvals, and allow / deny rules the organization has already configured there. SPECTRA grants itself nothing and asks for no exemptions — if the coding agent may not do something in your environment, neither may SPECTRA. Adopting SPECTRA changes what the agent produces, not what it is permitted to touch.
SPECTRA is compatible with a wide range of AI coding agents, so it runs on whichever one a team already uses:
AI-DLC is AWS's AI-Driven Development Lifecycle — introduced to fix a structural limit of the traditional SDLC: it's built around humans, with AI bolted on at the edges. AI-DLC inverts that and puts AI at the centre — AI drafts the plan and does the heavy lifting, while humans review and approve at each gate. That is the agentic SDLC described above. Its seven phases fold straight into AI-DLC's three — Inception, Construction, and Operation — carrying the same shared context and the same human gates with them. Both are loops, not lines: work moves phase by phase, and what Operation teaches feeds straight back into the next Inception. SPECTRA is ready for AI-DLC out of the box, so adopting it is itself how a team makes the shift, without giving up the discipline that keeps quality high.
Inside every AI-DLC stage, the rhythm of the agentic SDLC holds — the team validates at a gate, AI drafts and builds, the team reviews — run as short bolts (hours or days, not week-long sprints). The phases above slot straight into the AI layer below — no new process, no rework.
Spec, plan, design, tests, and code all live in and update the same context, so they can't silently diverge — the spec stays the contract and everything traces back to it.
Each phase inherits everything the last one knew — intent, constraints, prior decisions — so the agent reads the answer instead of guessing it.
Decisions and the trade-offs behind them are captured in the durable context, so settled questions stay settled and a deliberate choice is never mistaken for an accident.
Continuity plus a human gate at each step surfaces a misread where it's cheap to fix, before it propagates into implementation and test.
Most teams already use AI — as AI-assisted individuals. The product owner has an assistant for stories, the analyst another for requirements, and the architect, the developers and the testers each have their own. Every assistant has its own prompts, its own partial picture of the work, and nobody else’s rules. They speed up tasks; they don’t carry the work. People still do — and people still re-explain the context at every hand-off.
SPECTRA makes the team AI-native. Specialized agents join it as members: they work from one shared context, follow the same standards, and pass the same human gates as everyone else. The work moves through the team instead of being re-told at every desk — and the team gets leaner.
Every role has its own assistant, its own prompts, its own slice of context. The AI helps individuals; people still carry the work — and every hand-off.
Specialized agents join the team: same context, same rules, same gates. They draft and build; people own the decisions.
Illustrative team shapes, not a staffing formula — the point is where the work and the knowledge live.
In an AI-assisted team, what the project knows is scattered across people’s heads and private chat histories. Close the tab and it’s gone; hand the work on and it has to be retold.
SPECTRA keeps that knowledge in one place — the repository — as versioned files that every person and every agent reads from and writes to: the constitution and its standards, requirements and specs, plans and architecture decisions, tasks, test strategy and plans, and root-cause records. Documentation the team already has is brought in rather than left in a wiki nobody opens. Because it is just files under version control, it is reviewed like code and owned by the team — not by a tool, and not by whoever wrote the prompt.
Ask two assistants — or the same one twice — for the same thing without shared context, and you get two different answers: different structure, different assumptions, different style. The model isn’t broken; it is guessing at everything nobody told it.
Models stay probabilistic; SPECTRA narrows the spread. It fixes the inputs — standards encoded once, one shared context, templates that give every document the same shape — and it checks the outputs, with cross-artifact consistency and convergence checks and a person at every gate. The result is output that is more consistent, more repeatable, and far easier to review.
Speed is only an asset if you can trust it. In SPECTRA, agents can take on more — several drafts, several phases, several features in parallel — but nothing enters the shared context until a named person approves it at a gate. Adding agent capacity never adds unreviewed change.
Accountability stays where it belongs: the product owner signs off intent, architects sign off design, engineers review every change, QE decides what a finding means, and a maintainer merges. Every decision leaves a record in commits and reviews — and SPECTRA itself runs inside your coding agent’s existing permissions, with no new trust boundary (see section 06).
Put the first three together and the shape of the team changes. When agents carry the drafting and the building — with the same context and the same rules — people stop spending their days producing artifacts and passing them along, and spend them leading: setting direction, reviewing the work, and approving it at every gate — intent, design, implementation, quality. There are fewer hand-offs, far less re-explaining, and a smaller team can own the same scope. That is the picture at the top of this section.
The agentic engine does the drafting and the building. What makes SPECTRA enterprise-grade isn't only the method, the standards, and the gates around it — it's multi-agent orchestration and agentic AI engineering, with each agent tailored and designed for a specific phase or task, covering the SDLC end-to-end.
SPECTRA is not another AI vendor, another model, or another data path. It ships as instructions — command files that Spec Kit registers with the AI coding agent your organization has already approved, executed by that agent inside your existing environment. Whatever governs the agent therefore already governs SPECTRA.
Because those controls sit on the tool rather than on SPECTRA, they cascade automatically. There is no second policy to author, no second vendor assessment to run, and no path by which SPECTRA can operate outside the boundary the agent is already held to.
SPECTRA adds no model and makes no inference calls of its own. The approved vendor remains the only vendor in the loop.
Prompts and source travel the agent's existing path — never a SPECTRA one. Handling, residency, and retention rules apply exactly as written.
SPECTRA holds no credentials of its own. PR delivery uses your existing Git and GitHub login, and confirms before any push.
SPECTRA opens no network channel the agent does not already use, so proxy, egress, and data-loss controls keep their coverage.
Agent activity is captured exactly as it was before. Nothing moves outside the surface your logging already watches.
Standardized on Claude internally? You get agentic SDLC coverage under the rules already approved for Claude. A client on Kiro, Gemini, Copilot, or Cursor gets the same capabilities under their approvals. Governance travels with the tool the organization chose.
Inheriting the perimeter is the floor, not the ceiling. SPECTRA is also built to make policy enforceable rather than aspirational.
Markdown onlyThe published extension is six command files, four templates, and its licence, notice, trademark policy, and changelog. No scripts, no binaries, no post-install hooks — it can be read end to end before anyone installs it.
No telemetryThe spectra command reports nothing about you, your code, or your project. Its only network calls are read-only requests that fetch the published catalog, agent roster, and latest release number — and the release check can be switched off entirely.
Nothing to grantThe catalog is public: no vendor login, no access token, no elevated permissions requested at install.
Auditable & pinnableApache-2.0 with the source in the open, and every extension pins the Spec Kit version it was tested against. Commit the catalog file and the resolved source travels with the repository.
SPECTRA brings a spec-driven workflow your teams can trust — with the loop, the standards, and the human gates that make it safe to scale.
Get started →