Skip to content

Home

An open platform for building AI-SDLC — pipelines run the full development cycle with AI agents, tools extend goga with new capabilities, and specification-driven development based on CODEMANIFEST ships with it out of the box.

Languages

Python     JavaScript     Kotlin     Swift     Go

Agents

Claude     Codex     OpenCode     Cursor     Qwen

Why goga?

Code and contracts drift apart, and architecture lives only in someone's head, invisible to the agent that needs to extend it. Hard-won project knowledge dies in chat logs instead of traveling between repositories. Every team improvises its own agent workflow, so nothing is standardized or repeatable. And developers hover over the approve button, afraid to give an agent real autonomy.

Goga answers each of these:

Contracts as the source of truth. Every cell is a directory with a CODEMANIFEST file describing exactly what it exposes, what it imports, and how it expects to be used — enforced by validators, recoverable by parsers.

Knowledge that travels with the repository. Project know-how lives in usage files instead of dying in chat logs. Imported usages create a tracked dependency graph, and goga usages sync detects stale copies and brings them back in line with the source — context moves between repositories with the code.

Pipelines as a standardized process. A built-in pipeline runner takes a feature from a one-line idea all the way to acceptance — the same well-defined cycle every time, not an ad-hoc prompt chain. The whole pipeline runs inside an isolated in-container environment, and each stage gets its own fresh context window — safe enough to let the agent work without babysitting. By default stages stay interactive and keep you in the loop, and can be configured to run autonomously.

A tool ecosystem instead of a ceiling. goga install adds tools that bring their own skills and pipelines: documentation generation, translation, review, or an entirely custom development cycle. The built-in SDD workflow is just the one that ships first.

The result: a project that humans and AI agents can navigate, change, and reason about at the same level of abstraction.

Quick start

Install goga:

pipx install goga

Connect goga to your agent:

goga connect <agent>

Initialize a project — the interactive wizard sets up .goga/config.yml, language conventions, and (optionally) a Dockerfile:

goga init

Or scaffold from a copier repo template first (optionally with a #ref fragment), then answer only the questions the template left open:

goga init https://github.com/<you>/my-template.git

Ship a feature in two commands

Goga ships ready-to-use pipelines that run the full development cycles — goga calls them workrounds — inside an isolated container. After goga init, from inside your agent:

goga pipeline refinement
goga pipeline development

The refinement pipeline walks the product side — define → discover → specify → review — and ends with a reviewed task. The development pipeline picks it up and walks the engineering side stage by stage:

prototype-architecture → architecture-review → apply-architecture → code-design → design-review →
coding-plan → plan-review → commit-changes → accept-result

When the work does not need product elaboration, skip the early stages — for example, start refinement at discover:

goga pipeline refinement -s define

More shipped pipelines cover the remaining lifecycles — see Shipped Pipelines.

A pipeline-file answers what the pipeline does. An optional workflow file answers how the same pipeline should behave in this project — per-stage agent, extra prompt context, loop expansion, stage skipping — without forking the base file. See Pipelines for the full functional model, and Automation for unattended and CI runs.

Drive the cycle by hand

If you want explicit control over each step instead of running the whole cycle automatically, open your agent in the project directory and describe what you want to build:

/goga:specify <what you want to create>

The slash-command form requires a command-capable agent — see Slash commands. Each subsequent command takes the previous artifact as input and produces the next one. See Workflow for the two workrounds — refinement and development — and the entry depths each supports.

Next steps

  • Pipelines — Run the agent-driven cycle automatically with goga pipeline
  • Getting Started — Initialize your first goga project
  • Workflow — The agent-driven feature development cycle
  • Cells — Cell structure, usages, and CODEMANIFEST DSL reference
  • Configuration — Configure .goga/config.yml
  • CLI Reference — Full command reference
  • Languages — Contract extraction per language