quint-code

quint-code

quint-code
PROBLEM-OPS ENGINE

Make better decisions. Remember why you made them.

$ curl -fsSL https://quint.codes/install.sh | bash
Get Started -- | GitHub
Claude Code Cursor Gemini CLI Codex CLI Codex App Air

The problem

You and your AI make important decisions every day. You pick solutions confidently, intuitively, and even explain them clearly.

But there are many things silently going wrong:

The problem was never framed

You go straight to "use Kafka" before asking what's actually broken. Intuitive decisions feel fast and right — but intuition optimizes for familiarity, not for the problem at hand. Without a frame, you're solving something you never defined.

Comparison doesn't happen

You and your AI settle on the first reasonable, intuitive option. No alternatives explored, no tradeoffs weighed. What looks like a "decision" is actually an approximation — the average, the familiar, the first thing that fits. Not the best. Just the first.

"Why did we make that?"

Three months later, nobody remembers. The rationale disappeared into a chat thread you'll never find. Now you're reverse-engineering a decision from code comments and git blame.

"Is this still the right call?"

Traffic tripled. Team doubled. Requirements shifted. But the architecture decision from 8 months ago is frozen in time. Nobody tracks when assumptions go stale.

How it works

One command. The agent reasons for you.

Type /q-reason and describe your problem. The agent follows a structured operating system of thought: frames the problem before solving it, generates genuinely distinct alternatives, compares them fairly on declared dimensions, and records the decision with full rationale, rollback plan, and expiry date.

The agent auto-selects the right depth — tactical for quick reversible choices, standard for architectural decisions, deep for irreversible cross-team calls. You stay in the loop for every choice that matters.

$ /q-reason "How should we handle cross-service transaction failures?"

Full control. Five steps, each a slash command.

When you want to drive each phase manually — define dimensions before seeing options, enforce parity across variants, attach evidence with congruence levels.

1 /q-frame Define signal, constraints, optimization targets, acceptance criteria
2 /q-char Set comparison dimensions with roles — constraint, target, observation
3 /q-explore Generate genuinely distinct alternatives with weakest link per variant
4 /q-compare Fair comparison — same inputs, same scope, parity enforced
5 /q-decide Decision contract — invariants, rollback plan, refresh triggers, expiry

Reversible decision? Three steps.

For choices with blast radius under 2 weeks — library picks, API design, caching strategy. Skip characterization and formal comparison. Frame, explore, decide.

1 /q-frame What's broken, what constraints, what does solved look like
2 /q-explore 2-3 alternatives with tradeoffs
3 /q-decide Pick one, record why, set expiry

Capture what matters before it's forgotten.

You discover the auth token has a hard 4KB limit that breaks with more than 12 roles. You realize the retry logic silently swallows timeout errors. You pick JSON over Protobuf because the client SDK doesn't support binary yet. These things never make it into docs — but they shape every decision downstream.

You don't need to call /q-note yourself — the agent captures micro-decisions automatically when it notices them in conversation. You said "let's go with gRPC" — it's recorded with rationale before you move on. No rationale — no record. Conflicts with active decisions are flagged. Auto-expires in 90 days so your knowledge base doesn't rot.

$ /q-note "Auth token hard limit 4KB — breaks at 12+ roles, must split claims before RBAC expansion"

Built on First Principles Framework

quint-code is built on top of First Principles Framework by Anatoly Levenchuk — a rigorous, transdisciplinary architecture for thinking.

Read the FPF specification

Frequently asked questions

Why do I need quint-code when there are SDD frameworks? ↑
SDD frameworks give you a structure for writing specs. quint-code gives your AI agent an operating system for thinking — problem framing, fair comparison, evidence tracking, and decision lifecycle management. It's not a document format. It's a reasoning process that produces artifacts with computed trust scores, expiry dates, and rollback plans. You can use both — SDD for specs, quint-code for the decisions behind them.
How is this different from ADRs? ↑
ADRs are static markdown files you write after deciding. quint-code decisions are live artifacts — they have computed trust scores (R_eff) that degrade as evidence ages, expiry dates that trigger reviews, rollback plans with conditions, and they're searchable via full-text search. An ADR tells you what was decided. A quint-code decision tells you whether you should still trust it.
Can I use it on an existing project? ↑
Yes. Run quint-code init and then /q-onboard — the agent will scan your codebase and surface existing architectural patterns worth documenting. You don't need to retroactively document everything. Start with your next decision.
What happens when I switch between AI coding tools? ↑
quint-code stores everything in a local SQLite database with git-tracked markdown projections. The MCP server works with Claude Code, Cursor, Gemini CLI, Codex CLI, Codex App, and Air. Switch tools, your decisions stay. The knowledge is in your repo, not in a chat thread. Just make sure you initialized quint-code for the correct tool — default is Claude Code.
Isn't this overkill for small projects? ↑
Use /q-note for micro-decisions and /q-reason which auto-selects tactical mode for small choices. The overhead is one command. The value is remembering why you chose X in 3 months when everything breaks. Small projects become big projects. Decisions made early matter the most.
Does it work for teams or solo only? ↑
Currently solo-focused. The .quint/ directory is git-tracked, so teammates can read your decisions. But there's no collaborative editing, review workflows, or merge conflict resolution for the SQLite database yet. That's on the roadmap.
Is quint-code good for vibe coding? ↑
If you're building something you'll maintain for more than a week — yes. Vibe coding is fast until you hit a decision you made 2 months ago and can't remember why. /q-reason takes 30 seconds and saves you hours of archaeology later.

From the creator of quint-code

ivan zakutni

First Principles Engineering

Production AI systems. Software architecture decisions that don't age like milk. The same methodology behind quint-code — applied to real-world engineering problems.

Deep dives, not hot takes. For engineers who ship.