Tack

The Problem Nobody Was Talking About

Every AI coding tool in 2025-2026 followed the same pattern: start a session, explain your project, get help, close the session, lose everything. The next day you'd open Cursor or Claude Code and start from zero — re-explaining your stack, your architecture decisions, what you tried yesterday, what broke, and what the project is even supposed to do.

The models got smarter every few months. The context window got bigger. But the fundamental problem never changed: AI agents have no memory between sessions.

This isn't just an inconvenience. It creates real engineering problems. An agent picking up a project mid-sprint has no idea what decisions were made, what was intentionally deferred, or what constraints exist.

The standard workaround was a system prompt — a big block of text you paste into every session explaining your project. But system prompts are static. They go stale the moment you make a decision they don't reflect. They're manually maintained, which means they're never maintained.

How I Found the Problem

I didn't set out to build Tack. I found the problem by living it.

While building Flowly (an AI-powered IT helpdesk platform), I was using AI coding agents daily. Every session started with the same ritual: paste the project context, explain the architecture, remind the agent what we decided last time. The context block grew to thousands of tokens and was always slightly out of date.

The deeper problem surfaced when agents started making decisions that contradicted earlier sessions. One session would set up Neon Postgres; the next would suggest switching to Supabase without knowing Neon was a deliberate choice. I'd catch it, but only because I remembered — the agent never would.

What Tack Does

Tack is an architecture drift guard for agent-driven development. It gives AI agents and humans a shared project memory that persists across sessions, tools, and handoffs.

Declare Your Architecture

When you run tack init, Tack scans your project, detects what systems are present, and asks you to classify each as allowed or forbidden. This becomes your architecture spec — a YAML contract that defines what the project is supposed to look like.

# .tack/spec.yaml
allowed:
  - nextjs
  - prisma
  - stripe
forbidden:
  - drizzle
  - supabase

Detect Drift

tack status scans your project against the spec and identifies drift — systems that appeared without being declared, forbidden packages that got installed, or architectural decisions that contradict the contract. Drift items are tracked with timestamps.

This is the guardrail that catches agents going off-script. If Claude Code installs a package you explicitly forbade, Tack flags it before it becomes entrenched.

Persist Context

The .tack/ directory stores everything an agent needs to understand the project natively within the repo:

• context.md — what the project is, who it's for
• goals.md — current objectives
• decisions.md — append-only history of decisions with reasoning
• spec.yaml — the architecture contract

All of this is local, git-trackable, and human-readable. No cloud dependency. No network calls.

Integrate via MCP

Tack runs as a Model Context Protocol (MCP) server. Tools like Cursor and Claude Code can read project context and write back decisions through a structured protocol — no copy-pasting required.

claude mcp add --transport stdio tack-mcp -- npx tack-cli mcp

Technical Decisions

YAML-Driven Detection Over Hardcoded Rules

The detection system is driven by YAML rule files, not hardcoded TypeScript logic. Each rule defines a system with signals (package names, config files). If any signal matches, the system is detected. Adding detection for a new tool is a simple file addition, allowing for massive community extensibility.

Append-Only Logs Over Mutable State

Machine-managed state (logs, drift, audits) is append-only. This creates an auditable history where you can trace every scan and decision back to when it happened. Human-authored files remain freely editable to allow project intent to evolve.

Local-First, Offline-Only

Tack makes zero network calls. Everything runs locally. For developer tools, especially ones that read your codebase, trust is the hardest thing to earn. Making the tool completely local and open source removes the objection before it's raised.

Where Tack Sits in the Landscape

Tack is the only tool that combines persistent project context, architecture drift detection, structured handoffs, and MCP integration in a local-first package. It doesn't compete with powerful coding agents like Cursor or Copilot — it makes them better by giving them memory and strict guardrails.

What I Learned

Tack started as a much bigger idea involving validation workflows and momentum tracking. The version that shipped was dramatically smaller: init, status, watch, handoff, and an MCP server. That was enough to be useful.

The session-reset problem is real and underserved. Every developer using AI coding agents has felt this pain. Most have accepted it as normal. Tack exists because I was frustrated with my own workflow. I wasn't trying to find a market — I was trying to fix a daily annoyance. The best developer tools come from developers scratching their own itch.