Back to AI Pods

Spec-to-Ship Pod · Forge Spec

AI-built features, reviewable at every step.

A Spec-to-Ship Pod takes each feature from request to tested code through a spec, a plan and a task list your team can review before any code is written. It works in your repository on Forge Spec, and the workflow stays when the pod leaves — so every feature after that starts the same way.

In the box

One install, one versioned plugin

0

skills

One per step of the flow — constitution through acceptance.

0

expert personas

Analyst, architect, API, review, security, performance — on call, never blocking.

0

worker agents

Spawned for isolated or heavy work: frontend, backend, debugging.

0

guardrail hooks

Fire at session start, before a write, and as the edit lands.

0

artifact templates

Constitution, spec, plan, tasks, checklist and test cases.

0

tool bridges

Repo graph, document conversion, design and tracker, wired on install.

None of these are loose parts. Each skill hands its artifact to the next, the hooks enforce the same standards every one of them reads, and the whole chain has been tuned and verified on live client delivery.

The artifacts are plain markdown, so all seven major AI coding agents read the same spec, plan and tasks.

Who it is for

Is Forge Spec for you?

It earns its keep where the same decisions get made over and over. Where there is nothing to repeat, it is the wrong tool.

Best for

  • Teams already using a coding agent whose output nobody fully trusts yet.
  • Backlogs where the same feature shape ships again and again — the fiftieth change, not the first.
  • Organisations that want the paperwork in the repository, not in a portal.
  • A team that can name one backlog item to run as the pilot.

Not a fit for

  • A throwaway prototype. The spec is meant to outlive the code.
  • Teams that will not let a checkpoint block an edit — enforcement is the product.
  • Anyone expecting the kit to choose the architecture. It records decisions; engineers make them.
  • Shops with no coding agent in daily use — there is nothing for it to govern.

The output

This page was built this way. Here is its paperwork.

Not a sample we wrote for the website — the actual spec, plan and task list that produced the site you are reading, committed in its repository.

FromOne folder, per feature, in your repository

The specWritten by the specify step in PLAN
Acceptance Scenarios

1. Given the landing page is loaded,
   When the presenter scrolls top to bottom,
   Then all six sections appear in order
   with no layout shift.

2. Given the user prefers reduced motion,
   When the page renders,
   Then loop animations are disabled and
   content stays fully readable.

Acceptance criteria a tester can run without asking a question.

The planWritten by the plan step in PLAN
## Technical Context

Language:    pinned, with the runtime version
Testing:     the project's test runner
Performance: LCP < 2 s on landing
             filter response < 100 ms
             payload < 500 KB per page
Constraints: no runtime fetch
             server rendering by default

Constraints written down before code, so review has something to check against.

The task listWritten by the tasks step in PLAN
- [X] T032 [P] [US1]
      Create BrowseByType.tsx — three link
      cards, one per type, live counts.

- [X] T033 [US1]
      Create app/page.tsx — composes Hero,
      StatStrip, CuratedRow, BrowseByType.

- [X] T034 [P] [US1]
      Create marketplace-card.test.tsx —
      card click, copy button, badge.

Every task names its file. [P] marks what can run in parallel.

Members see the filenames and the unredacted stack. Sign in

Enforcement

Govern the generation, not the review.

A blocked edit costs seconds; the same mistake caught at review costs a day. Every checkpoint lands before a reviewer sees the code.

At session start

Before the agent reads anything

  • Rules survive a long session

    Your non-negotiables are re-injected when the agent’s memory compacts.

  • The repo map is kept fresh

    A stale code graph is worse than none — and confidently wrong.

Before the write

These two can refuse

  • Context is a precondition

    Your patterns, and the design behind the file, must be read before it can be written.

  • Protected files are refused

    Environment files, lockfiles and build output are blocked, not warned about.

As the edit lands

Runs on every change

  • Agent skills are scanned

    Editing an agent skill triggers a security scan of its directory.

  • Formatting never reaches review

    Formatters and linters run as each edit lands, so review is about the change.

Code review

Where most teams put all of this

By the time a change arrives here it has already been written, read and rewritten. That is the cost this replaces.

Both directions

The fiftieth change runs like the first.

Greenfield is the easy case. Coming back to a spec six months later is the one that decides whether any of this held — so it takes the same path, plus one step.

Shipping something new

The greenfield path — context first, code last.

  1. 01

    Define context

    Vision, architecture and coding conventions, written once per project.

  2. 02

    Write the spec

    A clear feature spec before any code exists.

  3. 03

    Plan tasks

    The spec broken into task chunks before implementation starts.

  4. 04

    Generate code

    Code plus unit tests, with a worktree per task so work runs in parallel.

  5. 05

    Review and ship

    Review agent, then the pipeline and a static-analysis scan before merge.

Coming back to change it

The path most tooling forgets — and the one you spend years in.

  1. 01

    Load the task

    The existing task list is loaded; pick the change or add one.

  2. 02

    Find the root cause

    The agent reads the codebase against the spec and proposes a scoped fix.

  3. 03

    Make the change

    Scoped to that task, in its own worktree so parallel fixes cannot collide.

  4. 04

    Verify no regression

    Review plus the full suite — the fix must prove it broke nothing else.

  5. 05

    Update the speccloses the loop

    The spec and task status are updated, and a changelog entry appended.

Portfolio

Tuned on real engagements, not a lab.

Techvify AI-SDLC Delivered 3× Faster Results For Australian Fintech Leader

An AI-orchestrated SDLC with a multi-agent copilot and LLM Gateway that turned a fintech leader's release cycle into weeks.

3x
Faster Development
90%+
Auto Code Coverage
50%
Faster To Market

AI-Driven Development For Edtech Client In Australia

A greenfield Azure product built by a lean 6-person team using a fully AI-driven development lifecycle from day one.

View case study
40%
Productivity Boost
<1.5D
PR Cycle
90%-
Security Incidents

AI Assisted Stock Exchange App For Singapore Client

A cloud-native, Agentic AI trading app with predictive insights and a premium cross-platform UX, built in six months.

85%+
Trading Volume Growth
6 Months
Launch
60%
Lower Infra Costs

How Kipanga Leveraged Techvify Dedicated Development Team For Growth

A three-year staff augmentation partnership scaling an Australian IT agency's custom software, web, and AWS delivery.

3-Year
Partnership
2x
Faster Scale-Up
4.9/5
Satisfaction

AI-Powered E-Learning App With Personalized Coaching

A GenAI e-learning platform with personalized coaching, dynamic lessons, multilingual NLP, and gamified progress.

1M+
Downloads
50+
Countries Reached
90%+
User Retention Rate

AI Assisted Logistics & Delivery Platform For Singapore Client

A three-platform logistics ecosystem with AI route optimization, a CarPlay courier app, and real-time customer tracking.

35%+
Faster Deliveries
28%
Less Fuel & CO2
3 Platforms
In 6 Months

Transforming Retail with AI-Powered CRM & Vision For Singapore Client

A Smart Retail CRM with AI vision, CCTV alerts, footfall heatmaps, and a store scheduler unifying every store location.

3.2x
ROI In Year One
40%
Less Shrinkage
25%
Smarter Scheduling

Fits your estate

Nothing here asks you to move.

It installs into your repository and reads from the systems you already run. No portal, no second backlog, no lock-in beyond markdown you own.

Runs inside your AI coding agent — any of the seven major ones

Reads from

  • Your work tracker

    The ticket that starts the work

  • Figma

    Components and states, not a screenshot

  • Your code graph

    Every call site, before it refactors

Forge Spec

installed in your repository

Writes back

  • The artifacts

    Committed beside the code they govern

  • Working code

    Task by task, every diff reviewed

  • Evidence on the ticket

    Pass/fail and linked bugs, back where it started

The ticket it started from is the ticket the evidence lands on

Extensions

Add what your project needs. Nothing it doesn’t.

Each extension adds commands to the workflow your team already runs. It installs into one repository at a time, so a project carries only the ones it uses — and teams contribute new ones through the same review: a security scan and a test install in a clean project before anything is listed.

5 extensions in the catalog

  • Your architecture decisions, checked against every plan

    3 commands

  • Your existing codebase mapped before the first spec is written

    4 commands

  • Reviewable commits during implementation, not one at the end

    1 command

  • Small issues fixed and larger ones logged after every implementation

    1 command

  • Load, soak and browser tests for your application, with pass/fail thresholds

    5 commands

Members only

Extension names, commands and install steps

5 extensions · 14 commands · in the members-only guidebook

Sign in to unlock

Start

Run one feature this way.

We take one item from your backlog and walk what a Spec-to-Ship Pod would produce for it. No obligation attached.