FAQ

Is this just ADRs with extra steps?

ADRs are static markdown files. Nobody checks if they're still valid. Nobody knows when reality diverged from the decision. Haft adds: computed trust scores (R_eff), evidence decay, code drift detection, module coverage, cross-project recall, claim verification, and an adversarial gate that challenges decisions before recording. ADRs are the starting point; haft makes them live.

What happens to decisions after they're recorded?

A markdown file appears in .haft/decisions/ — commit it with your code. The decision tracks affected files: if those files change, drift detection flags it. Evidence can be attached over time (test results, benchmarks). R_eff is computed from evidence quality. When R_eff drops below 0.5, the decision surfaces as stale in /h-status. You review and either waive (still valid), reopen (needs reconsideration), or supersede (replace with new decision).

Can I use this on an existing project?

Yes. Run haft init then /h-onboard. The agent scans your codebase for READMEs, ADRs, architecture docs, and captures what it finds as notes. It also runs module coverage to show which parts of your architecture have no decisions.

Does this work with Cursor?

Yes. Run haft init --cursor. This creates .cursor/mcp.json and installs commands in ~/.cursor/commands/. After init, enable the MCP server in Cursor Settings, find haft, and toggle on.

Is this useful for solo developers?

Yes — you'll thank yourself in 3 months when you can search "why did I pick PostgreSQL over SQLite?" and find the full reasoning, not a vague memory. Decisions accumulate across projects too: when you frame a similar problem in a new project, decisions from old projects surface automatically via cross-project recall.

Is this useful for teams?

Yes. Decision records commit to git — team members see them in PRs. Reviewers can challenge decisions alongside code. Module coverage shows the team which parts of the architecture are governed and which are blind spots.

In v6, haft sync enables the team workflow: each engineer pulls the repo, runs haft sync, and the markdown projections in .haft/ are imported into their local database. Decisions are reviewable in PRs, searchable locally, and stay in sync across the team through git.

What if I just want quick decisions?

Use /h-reason — the agent picks tactical mode (frame, explore, decide — no characterization or comparison). Or use /h-note to capture a micro-decision with rationale validation. You don't have to use the full cycle for every choice.

What's the overhead?

A tactical decision takes 30-60 seconds. A standard decision takes 3-5 minutes. The time investment pays back when someone (including future you) asks "why?" and the answer is there, with rationale, alternatives, and evidence.

What's FPF?

First Principles Framework — a formal specification for engineering reasoning by Anatoly Levenchuk. The FPF spec is public on GitHub. Haft implements the practical parts: the ADI reasoning cycle (Abduction-Deduction-Induction), evidence-based trust scoring (R_eff), weakest link aggregation (WLNK), and the decide-measure-reframe loop. You don't need to read the spec to use haft.

Where's the data stored?

Database: ~/.haft/projects/<project-id>/haft.db (SQLite, local, never leaves your machine). Markdown projections: .haft/ in your project (git-tracked, for code review). Cross-project index: ~/.haft/index.db (for cross-project recall).

Is haft good for vibe coding?

Vibe coding is coding without thinking about structure. Haft is a tool for thinking about structure. They solve different problems. That said, you can vibe-code all day and use /h-note to capture the interesting choices along the way — no ceremony needed. When you hit a real decision (database choice, auth strategy, deployment model), switch to /h-reason for 60 seconds of structured thought. Then go back to vibing.

What happened to quint-code?

Haft is quint-code, rebranded in v6.0. Same tool, same team, new name. The GitHub repository keeps the original URL. Internal directories changed from .quint/ to .haft/ and commands from /q-* to /h-*. If you're upgrading from v5, see the migration guide.

How does haft compare to SDD frameworks?

SDD (Specification-Driven Development) frameworks prescribe a methodology. Haft provides structure without prescribing process. You can use as much or as little of the FPF cycle as fits your workflow. The key difference: haft decisions are living artifacts with computed trust scores and drift detection, not static specs that rot in a wiki.