For solo devs & small teams shipping with AI coding agents

Write the spec once. Your board and your coding agents both follow it.

TaskFourge is project management for software builders — solo or with a small team — where the structured spec is the source of truth. Tasks derive from it, the kanban board derives from the tasks, and your coding agents pull the full context tree directly. Plan solo for free; share read-only with anyone.

Specs drive the board
Agents read them over MCP
Solo is free

Prompt Versioning

A feature spec inside the PromptDeck project

Approved

Problem

Prompt iterations live in scratch docs; nobody can say which version produced which eval score.

Approach

Immutable version history per prompt, diff view between any two versions, one-click safe restore.

Context bundle · via MCP

agent> get_task_context("diff-view")

✓ project PRD — the what & why

✓ feature spec — prompt versioning

✓ task spec — acceptance criteria

agent> create_feature("share-links")

✓ spec drafted — pending your approval

Why it exists

Most tools start at the board. TaskFourge starts at the spec.

The real plan — the what and why— usually lives in scattered docs your tools can't read.

The usual way

Start at the board. Tickets get titles, cards get dragged, and the real plan stays in your head — or in docs, threads, and screenshots nothing else can read.

The TaskFourge way

Start at the spec. Guided authoringwalks you through what a solid plan needs to answer — then tasks, the board, and your agents' context all derive from it. Humans and machines read the same source.

How it's different

One spec. Your team and your agents both read it.

Specs first. The board is a derived view.

Author the spec through guided, structured fields — not a blank box. Tasks are created from it, and the kanban board just visualizes them: editing the spec is what drives the work, not the other way around.

In Progress 3

Diff view between prompt versions

Prompt Versioning

Prompt comparison matrix

Eval Runs

Review: Prompt Library

Review task

AI-native, not AI-decorated.

Specs are structured fields, not text blobs — machine-readable by default. Any task can bundle its full ancestry (PRD → feature spec → task spec) and hand it to Claude Code, Codex, or any coding agent over MCP — the open protocol coding agents use to pull in context. The structure that sharpens your thinking is the same context layer your agents build from.

Project / Living PRD

The what & why everything inherits

Feature

Tech spec + mandatory review task

Task

Acceptance criteria, scope boundaries

Share with anyone, free. Build together on the paid tier.

Solo authoring, guided specs, and agent export are free. Share any project as a read-only link — no account, no seat required. When you want others editing with you — roles, real-time presence, collaborative approvals — that'll be the paid unlock.

The approval gate: agreed means agreed.

Before a spec hands work to an agent or a teammate, it passes an approval gate. When you're solo, it's auto-approved — you're never blocked on yourself. With a team, it's a real checkpoint: a moment where everyone has read and agreed to the plan. Edit an approved spec and it returns to pending, so “Approved” always means current — not just “approved once.”

Draft

Spec in progress

Pending approval

Real checkpoint with a team

Approved

Safe to build from — always current

One canonical path

Project → Feature → Task. Each carries a spec.

One guided flow from idea to buildable work — the same sequence whether a human walks it in the UI or an agent builds it over MCP.

step 1
Start at the project
Create the project and its living PRD — the top-level “what and why” everything inherits.
→
step 2
Break it into features
Features and the tasks within them — the concrete work the product needs, scoped under the project.
→
step 3
Spec every feature and task
Guided authoring walks you through what a solid spec needs to cover. Approved specs are what agents build from.

UI and MCP are two front-ends to the same flow — agents can build the tree or consume it.

The build, honestly

Where it stands.

TaskFourge is in active development. This is the honest state of the build.

Foundations

Done

The ground floor: stack, pipeline, and design language locked in.

Shipped: Stack chosen — Next.js, Supabase, Vercel
Shipped: CI + deploy pipeline live
Shipped: Local dev environment
Shipped: Product & design docs (PRD, design system)

Phase 1 — MVP

Now building

A complete solo, spec-first workspace: free sharing and agent-consumable context.

In progress: Design system & UI foundation
In progress: Accounts & auth
In progress: Authorization & data isolation (RLS)
In progress: Projects with project switcher
In progress: Guided creation flow (Project → Feature → Task)
In progress: Guided spec authoring at every level
In progress: Spec approval gate (auto-approve when solo)
In progress: Spec-derived kanban board
In progress: Task management (priority, labels, due dates)
In progress: Free read-only / link sharing
In progress: Solo real-time sync across tabs & devices
In progress: MCP context export for coding agents

Phase 2 — Collaboration

Planned

The paid unlock: building together, not just showing.

Invite editors with roles
Collaborative spec approval
Real-time presence & co-editing
Comments, subtasks & attachments
Activity feed
Multiple boards per project
Project & spec templates
Milestones & releases

Phases 3 & 4