The Receipts
37 tickets to build the team. 95 to build the product. 132 total. 18 days. 1 person. Not full-time.
37 tickets to build the team. 95 to build the product. 132 total. 18 days. 1 person. Not full-time.
This is the proof post. Post #1 told the story of how the Galactic Team was built — one afternoon, eight agents, markdown files. This one shows what came out the other side.
What we built to run the team
Galactic-team is the repository for the methodology itself. Before any product work could happen, the team needed a platform: agent prompts, workflow skills, integrations, and conventions for how decisions get made and tracked.
37 tickets later, here’s what exists:
The agents. 12 specialists, each defined in a markdown file. Not a system prompt with a hat on — actual character with expertise, tone, constraints, and specific instructions for what to do when a question falls outside their domain. The architect defaults to failure modes. The board advisor shows up with no tools and no files, just questions. The journalist documents everything. The platform engineer maintains the infrastructure that makes the rest possible.
The skills. 24 custom commands that compose into a complete development workflow: /briefing to orient each session, /consult to load a specific agent with the latest context, /roundtable to run all agents in parallel against a question, /take to claim a ticket and open a branch, /ship to commit and move it to review, /sprint to pull-dispatch all ready work autonomously. Each one was built from a problem — a friction point that kept recurring until someone wrote the fix.
The integrations. Jira (MCP + ACLI), Slack (MCP, session summaries to #galactic-log), GitLab (OAuth, branch, CI and PR creation), PostHog (product analytics, in-session query access for the product agent). All wired in the first two weeks.
The workflow. A custom 7-status pipeline — Backlog → Needs Discussion ←→ Ready ←→ In Progress → In Review → QA → Done — provisioned via REST API and applied to both projects. The “Needs Discussion” gate is the one that matters: nothing enters In Progress without first clearing an agent conversation. Tickets don’t get abandoned because they were half-formed.
The paper trail. 36 session logs documenting every decision, dated and version-controlled, in docs/galactic-story/. Not a wiki. Not a Notion page that goes stale. A file tree that mirrors the git history — you can read the commit and then read the decision that caused it.
29 of 37 GALACTIC-TEAM tickets are Done. The remaining 8 are in flight or explicitly deferred. The platform ran while it was being built — every improvement to the methodology applied immediately to the product work running alongside it.
What the team built with it
95 tickets for the product. Here’s what they cover.
Authentication. Clerk JWT validation in Symfony on the backend. Clerk React SDK in Next.js on the frontend. Both done, both in production code.
Design system. An SVG logomark. A design token foundation in tokens.css wired to Tailwind config. Card, button, and icon library components — all states, all variants. A design spec template for annotated wireframe handoffs. All done.
API. Full OpenAPI spec published via NelmioApiDocBundle. 4 GitHub repositories structured for the full stack. Symfony controllers rewritten from API Platform to plain output DTOs after the architect flagged overengineering.
Product screens. A full set of coded screens: marketing, onboarding flow, core feature views, and a management interface. Not wireframes — production code.
Observability. OpenTelemetry instrumentation in both Symfony and Next.js. PostHog configured and shipping data. UTM tracking for content attribution.
CI. Pre-commit hooks, Vitest + React Testing Library harness, GitLab CI pipelines for lint, test, build, and SAST — all set up in week three.
That’s two full codebases, a design system, an API layer, and an observability stack. Built in the time it usually takes a solo founder to finish defining the MVP.
What made this possible
The velocity isn’t from moving fast. It’s from not doing the same thing twice.
Every ticket traces to a decision. Every decision traces to an agent conversation. When an architectural question came up mid-implementation, it didn’t get answered in a comment or a Slack thread that disappeared. It went to Needs Discussion, triggered a session with Galen or Obi-Wan, and came back as a decision file with an acceptance criterion attached.
The graduation pipeline does most of the work: fuzzy question → agent session → decision file → Jira ticket → implementation. By the time something becomes a ticket, the ambiguity is gone. The ticket doesn’t need to grow a comment thread of clarifications. It gets picked up and built.
This is also why the 78% Done rate on the platform holds. The system wasn’t built speculatively — every ticket represented a specific friction point that had already been identified, discussed, and decided. No “nice to have” accumulation. No backlog rot.
What the numbers don’t show
132 tickets across 18 days isn’t 132 features. It includes configuration tasks, design sessions, spikes, and architectural decisions. Some tickets took 20 minutes. Some ran across multiple sessions with multiple agents.
PROJECT-40 (a core data model) spawned three follow-up tickets when the implementation uncovered scope. GALACTIC-TEAM-23 (startup token cost) changed how every agent initializes — one ticket, one session, cascading improvement on every session that followed. The metric that matters isn’t volume. It’s the ratio of tickets that shipped to tickets that stalled.
That ratio is high because the work was shaped before it started. Agents don’t solve implementation problems — they prevent them. The problem with most AI-assisted development is that the AI does the thinking after you’ve committed to the approach. The advisory model does it before.
One person. Twelve agents. 132 tickets. Eighteen days. Nights and weekends.
The bottleneck was never the output. It was always the clarity of the question going in.