Thinker
Thinker
Thinker Toolkit
Compatible Environments
Claude Code
Cursor
VS Code
Google Antigravity

Give your IDE a sharper mind.

Bring focused workflows, structured engineering disciplines, and modular skills directly into your everyday coding environment.

Disciplines your AI follows.
Connected across every step.

Standard coding tools modify files based on guesswork. Thinker guides your AI through four continuous engineering stages—connected in a single verified pipeline.

$npx thinker-toolkit init
01 // STAGE ONE

Root cause before
any code modification.

The agent is strictly prohibited from making speculative edits. It must reproduce the defect in an isolated automated test, verify the failure, and isolate the exact root cause first.

Zero speculative patchesFalsifiable hypothesis
TSreproduce-session.spec.ts
1// Phase 1: Prove defect deterministically before touching code
2
test("concurrent refresh drops session token", async() => {
3
const results = await simulateBurstTraffic(50);
4
expect(results.sessionActive).toBe(true);
5
});
AssertionError: expected null to be true
Session token null at iteration 14 of 50 under concurrent refresh load.
main*
Repro verified · Exit 1
Pre-Commit Contract Barrier
POST /api/v2/orders100% Schema Match
GET /api/v2/session100% Schema Match
Public Interface Signatures18 / 18 Intact
Gate verification before pull request submissionBarrier Satisfied
02 // STAGE TWO

Write the tests first.
Protect every contract.

Agents often write code that looks functional but silently degrades edge cases. Thinker forces invariant tests to be created first, keeping public APIs and type contracts unshakeable.

Zero silent regressionsRuntime & build-time safety
03 // STAGE THREE

Parallel subagents.
Zero workspace collisions.

Dispatching multiple agents to refactor or build features shouldn't destroy your git tree. Thinker runs each agent in a dedicated Git worktree on disk with fast-forward merges.

Lock-free workspacesAutomatic clean merge
Concurrent Worktree Orchestrator
3 Isolated Branches
Fast-forward sequential merge verified: 0 file conflicts84s total

Terminal is idle. 0 lines rendered.

Engineered for your stack.
Zero proprietary lock-in.

Thinker doesn't force a new editor or proprietary cloud. It injects strict engineering disciplines directly into your existing IDE—running 100% locally.

Local Sandbox · Zero Telemetry
05 // STAGE FIVE

Native rules in your IDE.
Zero background daemons.

One command generates transparent markdown specs and native configuration files tailored for your editor. No SaaS subscription, no proprietary cloud relays, and no vendor lock-in.

Transparent markdown specsNative IDE configuration
CLAUDE.md
1# CLAUDE.md — Thinker Discipline Protocol
2// Core Invariants automatically injected into workspace
3
1. Reproduce defect in isolated test before editing code.
4
2. Protect API contracts: verify schema signatures intact.
5
3. Dispatch parallel agents in dedicated Git worktrees.
6
4. Pre-completion gate: thinker verify --strict
Injected to CLAUDE.md(Git tracked)
Active
main*
100% Open & Git-Tracked
Local Sandbox & Git Hooks
1#!/bin/sh
2# .git/hooks/pre-commit — Fail-Closed Gate
3
echo "✦ Thinker pre-commit gate: verifying invariants..."
4
npx thinker verify --strict
5
if [ $? -ne 0 ]; then exit 1; fi
Non-bypassable Git hook(agent cannot fake pass)
Active
Local Disk
Fail-Closed Protected
06 // STAGE SIX

Stored in your repo.
Never on a remote server.

Your code, branch clones, and test logs stay strictly on your local machine. Thinker installs native git pre-commit hooks that enforce quality fail-closed—preventing AI agents from talking their way past failing tests.

Zero remote telemetryNon-bypassable git hooks