The Agentic Coding FlywheelTL;DR Edition
16 core tools and 24 supporting utilities that transform multi-agent AI coding workflows. Each tool makes the others more powerful - the more you use it, the faster it spins. While others argue about agentic coding, we're just over here building as fast as we can.
Why a Flywheel?
A flywheel stores rotational energy - the more you spin it, the easier each push becomes. These tools work the same way. The more you use them, the more valuable the system becomes.
Every agent session generates searchable history (CASS). Past solutions become retrievable memory (CM). Dependencies surface bottlenecks (BV). Agents coordinate without conflicts (Mail). Each piece feeds the others.
The result: I shipped 20,000+ lines of production Go code in a single day with BV. The flywheel keeps spinning faster - my GitHub commits accelerate each week because each tool amplifies the others.
Tap or hover a tool to see its connections
Core Flywheel Tools
16The backbone of multi-agent development: session management, communication, task tracking, static analysis, memory, search, safety guards, multi-repo sync, and automated setup. These tools form a self-reinforcing loop where each makes the others more powerful.
A mail-like coordination layer for multi-agent workflows. Agents send messages, read threads, and reserve files asynchronously via MCP tools - like Gmail for AI coding agents. HTTP-only FastMCP transport with static export.
Why It's Useful
Critical for multi-agent setups. When 5+ Claude Code instances work the same codebase, they need to coordinate who's editing what. Agent Mail prevents merge conflicts via advisory file reservations with pre-commit guard enforcement, and builds an audit trail of all agent decisions via SQLite + Git dual persistence.
Key Features
- Threaded messaging between AI agents
- Advisory file reservations
- SQLite-backed persistent storage
- MCP integration for any compatible agent
Tech Stack
Synergies
A fast terminal UI for viewing and analyzing Beads issues. Applies graph theory (PageRank, betweenness centrality, critical path) to identify which tasks unblock the most other work.
bv --robot-triageWhy It's Useful
Issue tracking is really a dependency graph. BV lets Claude prioritize beads intelligently by computing actual bottlenecks. The --robot-insights flag gives PageRank rankings for what to tackle first.
Key Features
- PageRank-based issue prioritization
- Critical path analysis
- Robot mode for AI agent integration
- Interactive TUI with vim keybindings
Tech Stack
Synergies
Local-first issue tracking for AI agents. SQLite for fast local queries, JSONL export for git-friendly collaboration. Full dependency graph with blocking/blocked-by relationships, priorities P0-P4.
br ready --jsonWhy It's Useful
Your issues travel with your repo - no external service required. Non-invasive design: never runs git commands automatically. Agents can create, update, and close issues with simple CLI commands. The bd alias provides backward compatibility.
Key Features
- Local-first issue storage
- Dependency graph tracking
- Labels, priorities, comments
- JSON output for agents
Tech Stack
Synergies
Blazing-fast search across all your past AI coding agent sessions. Indexes 11 agent formats: Claude Code, Codex, Cursor, Antigravity/Gemini, ChatGPT, Cline, Aider, Pi-Agent, Factory, OpenCode, Amp. Sub-60ms queries with optional semantic search.
cass search "auth error" --robotWhy It's Useful
You've solved this problem before - but which session? CASS lets you search 'how did I fix that React hydration error' and instantly find the exact conversation. Three search modes (lexical, semantic, hybrid), HTML export with encryption, and multi-machine sync via SSH.
Key Features
- Unified search across all agent types
- Sub-second search over millions of messages
- Robot mode for AI agent integration
- TUI for interactive exploration
Tech Stack
Synergies
One-command bootstrap that transforms a fresh Ubuntu VPS into a fully-configured agentic coding environment. CLI provides doctor (47+ health checks), update (category-specific), cheatsheet (50+ aliases), and session management.
Why It's Useful
Setting up a new development environment takes hours. ACFS does it in 30 minutes, installing 35+ tools, six AI agent CLIs (three by default, three optional), and all flywheel tooling. Post-install CLI provides `acfs doctor` for health checks and `acfs update` for maintenance.
Key Features
- acfs doctor: 47+ health checks across 7 categories
- acfs doctor --deep: Functional tests (auth, DB connectivity)
- acfs update: Category-specific with --dry-run preview
- acfs cheatsheet: 50+ aliases for modern CLI tools
- acfs dashboard: Static HTML dashboard generation
- Update logging to ~/.acfs/logs/updates/
Tech Stack
Synergies
A meta-runner that fans out per-language scanners across 8 languages (JS/TS, Python, Go, Rust, C/C++, Java, Ruby, Swift). Uses ast-grep for AST-based pattern matching with 18 detection categories and 1000+ bug patterns.
ubs file.tsWhy It's Useful
AI coding agents move 10-100x faster than humans. UBS keeps pace with sub-5-second scans and auto-wires guardrails into Claude Code, Codex, Cursor, Antigravity, and Windsurf agents. The --beads-jsonl output creates Beads issues directly from findings.
Key Features
- 1000+ built-in detection patterns
- Consistent JSON output format
- Multi-language support
- Perfect for pre-commit hooks
Tech Stack
Synergies
Claude Code PreToolUse hook that blocks dangerous commands BEFORE execution. 50+ packs across 17 categories: git (reset --hard, force push), filesystem (rm -rf), databases (DROP TABLE), Kubernetes, cloud providers, and more.
dcg doctorWhy It's Useful
AI agents can and will run 'rm -rf /' if they think it solves your problem. DCG catches catastrophic commands before they execute with sub-millisecond latency. Safe directory exceptions (/tmp, /var/tmp, $TMPDIR) allow temp operations without friction.
Key Features
- Intercepts rm -rf, git reset --hard, etc.
- SIMD-accelerated pattern matching
- Configurable allowlists
- Command audit logging
Tech Stack
Synergies
Multi-repo management system: sync 100+ repos, AI-assisted code review with priority scoring, dependency updates across package managers, and agent-driven commit automation.
ru sync --parallel 4Why It's Useful
Managing 100+ repos manually is impossible. 'ru sync' handles clone/pull in parallel. 'ru review' discovers issues/PRs via GraphQL batch queries, scores by priority (security+50, bugs+30, age), and spawns isolated Claude Code sessions in worktrees.
Key Features
- One-command multi-repo sync
- Parallel operations
- Conflict detection with resolution hints
- AI code review integration
Tech Stack
Synergies
Cross-agent procedural memory system. Transforms scattered sessions from all your AI agents into persistent, unified knowledge. Three-layer cognitive architecture: Episodic (raw sessions via CASS) → Working (diary summaries) → Procedural (playbook rules with confidence tracking).
cm context "task" --jsonWhy It's Useful
A debugging technique discovered in Cursor is immediately available to Claude Code. Rules have 90-day decay half-life and 4× harmful weight for mistakes. Bad rules auto-invert into anti-pattern warnings. Every agent learns from every other agent's experience.
Key Features
- Three memory layers: episodic, working, procedural
- MCP integration for any compatible agent
- Automatic memory consolidation
- Cross-session context persistence
Tech Stack
Synergies
A multi-agent tmux orchestration tool with 80+ commands. Spawns Claude, Codex, and Antigravity agents in named panes with type classification (cc/cod/agy). Monitors context windows, detects file conflicts, and provides robot mode for automation.
Why It's Useful
Running multiple AI agents simultaneously creates chaos without orchestration. NTM provides the command center: spawn agents with one command, broadcast prompts to specific types, monitor context usage, and coordinate via Agent Mail. Sessions persist across SSH disconnects and system reboots.
Key Features
- Named agent panes with type classification
- Broadcast prompts to agent types
- Session persistence across reboots
- Dashboard view of active agents
Tech Stack
Synergies
Nuclear-launch-style two-person rule for dangerous commands. Four risk tiers classify commands via 40+ regex patterns: CRITICAL (2+ approvals), DANGEROUS (1 approval), CAUTION (30s auto-approve), SAFE (skip). Cryptographic signing, rollback support, and outcome analytics.
Why It's Useful
AI agents can and will run destructive commands if they think it solves your problem. SLB intercepts commands like 'rm -rf /', 'DROP DATABASE', and 'terraform destroy' requiring explicit approval from another agent or human reviewer before execution. Watch mode lets reviewing agents stream pending requests.
Key Features
- Two-person rule enforcement
- Command queue with approval workflow
- Pattern-based risk detection
- SQLite persistence
Tech Stack
Synergies
Local-first skill management platform: dual persistence (SQLite + Git), hybrid search (BM25 + semantic + RRF), UCB bandit optimization, multi-layer security (ACIP + DCG), graph analysis via bv, MCP server for AI agents.
Why It's Useful
AI agents need reusable context to be effective. MS doesn't just store skills—it learns which ones work via UCB bandit optimization. Context-aware auto-loading suggests skills based on project type. Pack contracts optimize token budgets. The MCP server makes skills native tools for any AI agent.
Key Features
- MCP server for native AI agent integration
- Thompson sampling optimizes suggestions
- Multi-layer security
- Hybrid search with RRF
Tech Stack
Synergies
Claude Code PreToolUse hook that offloads Rust compilation to remote workers. Intercepts cargo commands, syncs source via rsync + zstd, compiles on server-grade hardware, streams artifacts back.
rch statusWhy It's Useful
Multi-agent swarms trigger many concurrent builds. RCH intercepts commands before execution and routes them to remote workers with health probes and priority scheduling. Agent detection coordinates builds across Claude Code, Codex, and Antigravity sessions.
Key Features
- Transparent cargo interception
- Multi-worker pool with priority scheduling
- Incremental artifact sync
- Daemon mode with status monitoring
Tech Stack
Synergies
Manages multiple accounts for Claude Code, Codex CLI, and Antigravity CLI with sub-100ms switching. Vault profiles store auth files for instant activation without browser flows. Smart rotation algorithms automatically select the best profile based on cooldown state, health, and usage patterns.
caam statusWhy It's Useful
When running multiple agents, you'll hit rate limits. CAAM lets you switch accounts instantly - no browser login, no waiting. Profile isolation enables parallel sessions where each agent uses its own credentials. Health scoring (🟢/🟡/🔴) shows which profiles are ready vs. cooling down.
Key Features
- Sub-100ms account switching
- Multi-provider support
- Automatic key rotation
- Session state preservation
Tech Stack
Synergies
Terminal hypervisor that captures pane output in real-time, detects agent state transitions through pattern matching, and enables event-driven automation across multiple AI coding agents.
Why It's Useful
When running multiple AI agents in WezTerm, you need to know when they hit rate limits, complete tasks, or need approval. WA observes all panes with sub-50ms latency and triggers automated responses.
Key Features
- Real-time terminal observation
- Intelligent pattern detection
- Robot Mode JSON API
- Event-driven automation
Tech Stack
Synergies
Multi-agent scientific research orchestration platform based on Sydney Brenner's methodology. Manages full research artifact lifecycle: hypotheses, discriminative tests, anomalies, critiques, and evidence packs with cockpit runtime for parallel agent sessions.
Why It's Useful
Transforms AI agents into a collaborative research group with rigorous scientific discipline. The Brenner approach emphasizes exclusion over accumulation, third-alternative thinking, and discriminative experiments that collapse hypothesis space fast.
Key Features
- Primary source corpus with citations
- Multi-agent research sessions
- Discriminative test ranking
- Adversarial critique generation
Tech Stack
Synergies
Supporting Tools
24Extend the ecosystem with GitHub issue sync, archive search, and prompt crafting utilities. These tools enhance the core flywheel for specialized workflows.
Downloads full-resolution images from iCloud, Dropbox, Google Photos, and Google Drive share links using a four-tier capture strategy with headless Chromium automation.
Why It's Useful
When debugging remotely, users share cloud links but you're SSH'd into a headless server. GIIL's four-tier capture (download button → CDN interception → element screenshot → viewport fallback) ensures maximum quality retrieval for AI agent analysis.
Key Features
- iCloud share link support
- CLI-based image download
- No browser required
- Works over SSH
Tech Stack
Synergies
Installs ananicy-cpp with curated rules to auto-deprioritize background processes. Includes sysmoni Go TUI (Bubble Tea) with IO throughput, FD counts, per-core sparklines, JSON export. Works on Linux and WSL2.
Why It's Useful
When running cargo build, npm install, or multiple AI agents, SRPS prevents unresponsive systems by lowering priority of known resource hogs. Safety-first: no automated process killing. Helper tools for diagnostics.
Key Features
- Automatic process deprioritization
- Real-time TUI monitoring
- 1700+ pre-configured rules
- Custom rule creation
Tech Stack
Synergies
Ultra-fast search over X/Twitter data archives with sub-millisecond latency. Uses hybrid BM25 + semantic search with Reciprocal Rank Fusion. Indexes tweets, likes, DMs, and Grok conversations.
Why It's Useful
Your X archive is a goldmine of bookmarks, threads, and ideas, but Twitter's search is terrible. XF makes your archive instantly searchable (<10ms) with both keyword and semantic matching. DM context search shows full conversation threads.
Key Features
- Sub-second search over large archives
- Semantic + keyword hybrid search
- No external API dependencies
- Privacy-preserving local processing
Tech Stack
Synergies
World-class terminal UI for combining source code files into LLM-ready prompts. Tree explorer with vim-style navigation, live syntax preview, token counting, and structured XML-like output optimized for AI parsing.
Why It's Useful
Crafting prompts with code context is tedious and error-prone. S2P provides visual file selection with sizes and line counts, real-time token/cost estimation, quick file-type shortcuts (1-9,0,r), and produces structured output that LLMs parse reliably.
Key Features
- Interactive file selection
- Real-time token counting
- Clipboard integration
- Gitignore-aware filtering
Tech Stack
Synergies
Iterative specification refinement via GPT Pro 5.2 Extended Reasoning + Oracle. Document bundling (README + spec + impl), convergence analytics with weighted scoring, session management, and robot mode JSON API for coding agents.
Why It's Useful
Complex specs need 15-20 review cycles. APR automates the loop: rounds 1-3 fix architecture, 4-7 refine interfaces, 8-12 handle edge cases, 13+ polish abstractions. Convergence score (≥0.75 = stable) tells you when to stop.
Key Features
- Automated multi-pass refinement
- Extended AI reasoning integration
- Markdown-based plan processing
- Progressive structure improvement
Tech Stack
Synergies
Official CLI for jeffreysprompts.com - browse, search, and install battle-tested prompts as Claude Code skills. Features interactive fzf-style picker and task-based suggestion engine.
Why It's Useful
Instead of writing prompts from scratch, install proven patterns. The interactive mode (jfp i) lets you fuzzy-search the entire library, while jfp suggest recommends prompts based on your task description. Premium features include collections, cross-machine sync, and a skills marketplace.
Key Features
- One-command skill installation
- Browsable prompt categories
- Claude Code skills integration
- MCP server for agent access
Tech Stack
Synergies
Bayesian-inference zombie/abandoned process detection using four-state classification (Useful, Useful-but-bad, Abandoned, Zombie) with evidence-based posterior probability scoring.
pt scan --format jsonWhy It's Useful
When builds hang or test runners go rogue, PT computes P(state|evidence) using process type, age, CPU/IO activity, memory, and past decisions. Confidence levels (very_high >0.99 to low <0.80) guide safe termination with identity validation and staged kill signals.
Key Features
- Intelligent process scoring
- Interactive TUI selection
- Robot mode for automation
- Resource usage analysis
Tech Stack
Synergies
Rust implementation of TOON (Token-Optimized Object Notation). Encodes JSON to TOON and decodes it back, so structured data costs fewer tokens in an LLM context.
Why It's Useful
LLM context windows are precious. JSON spends tokens on quotes, braces and commas; TOON writes the same records as indented key-value lines and header-plus-rows tables, cutting tabular payloads by roughly half.
Key Features
- 40-70% token count reduction
- Multi-language support
- Token count statistics
- Reversible compression
Tech Stack
Synergies
Transparent HTTP/HTTPS proxy for debugging and inspecting network traffic. Routes requests through a local proxy for analysis.
Why It's Useful
When debugging API integrations or AI agent network calls, you need visibility into what's being sent and received. Rust Proxy provides transparent interception without modifying your code.
Key Features
- Transparent HTTP/HTTPS proxying
- Request/response logging
- Latency measurement
- Header inspection
Tech Stack
Synergies
Network observer for AI CLI tools that logs requests and responses without proxying. Passive monitoring of LLM API traffic.
Why It's Useful
Understanding what your AI agents are actually sending to APIs helps with debugging, cost tracking, and optimization. RANO passively observes network traffic without adding proxy overhead.
Key Features
- Transparent HTTP proxy interception
- Provider-aware log parsing
- Token and cost tracking
- Real-time traffic monitoring
Tech Stack
Synergies
Converts websites to clean Markdown for LLM consumption. Strips ads, navigation, and boilerplate to extract just the content.
Why It's Useful
AI agents need web content in a format they can understand. MDWB fetches pages and converts them to clean Markdown, perfect for feeding into LLM context windows.
Key Features
- Clean content extraction
- Code block preservation
- Link handling
- Pipe-friendly output
Tech Stack
Synergies
Fixes malformed ASCII art diagrams generated by AI. Corrects alignment, box characters, and connection lines.
Why It's Useful
AI models often generate ASCII diagrams with alignment issues, broken lines, or inconsistent characters. AADC automatically detects and fixes these problems.
Key Features
- Auto-repair box alignment
- Connector line fixing
- Before/after diff preview
- Clipboard integration
Tech Stack
Synergies
Tracks LLM provider usage across multiple coding agents. Monitors API calls, token consumption, and costs.
Why It's Useful
When running multiple AI agents simultaneously, costs can spiral. CAUT provides visibility into which agents are using how many tokens and at what cost.
Key Features
- Multi-provider usage aggregation
- Per-session token breakdown
- Cost estimation and trends
- Export to CSV/JSON
Tech Stack
Synergies
Two-tier hybrid local search, shipped as a Rust library and the standalone fsfs CLI. Each query runs BM25 lexical search alongside a fast semantic tier and fuses them with Reciprocal Rank Fusion for an immediate answer, then refines the top candidates with a higher-quality embedding model.
fsfs search "query"Why It's Useful
grep only finds exact text; fsfs adds intent-level recall without a remote service. Indexing and search run on your machine (network is only needed for model downloads, update checks, and opt-in query expansion), and agents get streaming jsonl or TOON output plus fsfs explain to see why a hit ranked where it did.
Key Features
- BM25 lexical + semantic retrieval
- Progressive delivery (fast initial + quality refinement)
- Local ML model support
- JSON API for agent integration
Tech Stack
Synergies
A Rust CLI that gives coding agents a durable, local memory layer. It stores facts, decisions, procedural rules, anti-patterns, and session evidence, indexes them with lexical and semantic search, and emits token-budgeted context packs where every item carries provenance and a score breakdown.
ee pack "fix the auth bug"Why It's Useful
Fresh agent sessions re-discover conventions and walk into traps another agent already hit. EE gives the harness somewhere to look: ee remember captures a lesson, ee pack pulls relevant memory before a task, and ee why explains a suspicious ranking. No cloud service or paid LLM API is required.
Key Features
- Hybrid BM25 + local vector retrieval with explainable scores
- Typed durable memories with confidence decay
- CASS session import turns agent history into evidence
- Token-budgeted context packs with deterministic hashes
Tech Stack
Synergies
Disk-pressure defense for AI coding workloads on Linux and macOS. It monitors free space, predicts exhaustion, and reclaims space in layers: pre-allocated ballast files it can release instantly, scored cleanup of stale build artifacts, and a zero-write emergency mode for disks that are already full.
sbh statusWhy It's Useful
A dozen agents running builds can fill a disk between cron runs, and at 100% builds fail mid-compile, SQLite databases can corrupt, and even cleanup tools can't write temp files. SBH reacts before that point, never touches protected or in-use paths, and records why it removed or kept every candidate.
Key Features
- Predictive disk space monitoring
- Safe cleanup policies
- Ballast file release
- Explainable policy decisions
Tech Stack
Synergies
Resumes a coding session created in one agent inside a different one. CASR finds the session across installed providers, reads it into a canonical session model, writes a native session file for the target (Claude Code, Codex, Gemini CLI, and more), re-reads it to verify fidelity, and prints the exact resume command.
casr resume cod <session-id>Why It's Useful
Sessions are siloed by provider: a useful Codex session can't be resumed in Claude Code, and vice versa. CASR lets you switch models mid-task, or route around a provider outage or rate limit, without rebuilding context from scratch.
Key Features
- Cross-provider session conversion
- Canonical session model
- 14+ provider support
- Session listing and inspection (casr list, casr info)
Tech Stack
Synergies
Fallback release infrastructure for when GitHub Actions is throttled. DSR watches Actions queue times and, past the threshold (10 minutes by default), runs your existing release workflow locally via nektos/act, builds macOS and Windows targets natively over SSH, and uploads the artifacts to GitHub Releases.
dsr release ntm 1.2.3Why It's Useful
Peak-time Actions queues can hold a release for 20+ minutes. DSR reuses your .github/workflows/release.yml instead of a parallel build system, so you ship the same artifacts without the queue, signed with minisign and accompanied by an SBOM.
Key Features
- Reuses existing GitHub Actions YAML
- Local builds via nektos/act
- Multi-platform support
- Artifact signing with minisign
Tech Stack
Synergies
Backs up AI coding agent configuration folders (~/.claude, ~/.codex, ~/.cursor, ~/.gemini, and more), giving each agent its own git repository. Every backup is a commit, so you get full history, diffs since the last backup, and restores to any commit or named tag.
asb backupWhy It's Useful
Agent configs accumulate settings, hooks, and customizations that are painful to rebuild after a bad experiment or a reinstall. ASB versions them: preview a restore before applying it, export an archive to move to another machine, and schedule backups with cron or a systemd timer.
Key Features
- Per-agent git repositories
- Full version history
- Easy restoration
- 13+ agent type support
Tech Stack
Synergies
A Claude Code hook that fires after context compaction and injects a reminder telling Claude to re-read AGENTS.md before doing anything else. It is a single SessionStart hook with a compact matcher, installed globally into ~/.local/bin and ~/.claude/settings.json.
printf '{"session_id":"demo","source":"compact"}\n' | claude-post-compact-reminderWhy It's Useful
Compaction drops the AGENTS.md rules Claude read at the start: forbidden commands, conventions, coordination rules. PCR puts them back in front of the model at exactly that moment, in every project, with nothing to maintain.
Key Features
- Auto-detects compaction events
- Injects AGENTS.md re-read reminder
- Zero overhead when not compacting
- Configurable reminder text
Tech Stack
Synergies
A clean-room Rust Markdown renderer and fmd CLI that turns Markdown into self-contained HTML, compact tagged PDF, and browser/WASM output from one parsed AST. The engine library has zero third-party dependencies; the default build adds only clap for the CLI.
fmd README.md --out README.htmlWhy It's Useful
Getting both a portable HTML page and a polished PDF from the same Markdown usually means a browser, LaTeX, or a Python or Node stack. fmd is one binary: fmd README.md --out README.html gives a single-file preview, and --to pdf gives a deterministic PDF with selectable text.
Key Features
- Self-contained HTML with inlined CSS, fonts, and dark mode
- Tagged compact PDF with real typography from the same AST
- Deterministic renders: same input yields same bytes
- Clean-room syntax highlighting plus Mermaid and SVG fidelity
Tech Stack
Synergies
A from-scratch Rust port of Mario Zechner's Pi coding agent, installed as the single pi binary. It streams responses with inline extended thinking, ships 36 built-in tools, and runs in interactive TUI, print (pi -p), RPC, and Agent Client Protocol modes.
pi "refactor this function"Why It's Useful
A native single binary avoids managed-runtime startup overhead, and the ollama, llama.cpp, and mistral.rs providers need no API key. Extensions are capability-gated with dangerous shell commands blocked before spawn, and print mode never silently auto-approves tool calls.
Key Features
- Streaming responses with inline extended thinking
- Full built-in toolset plus Markdown-defined Rust subagents
- Multi-provider support including zero-config local models
- Capability-gated extensions with two-stage exec mediation
Tech Stack
Synergies
Recovers crashed coding-agent sessions after a hard power cut. PFR uses pre-boot mtime crash-cluster detection to find the sessions that died, freezes them into a recovery plan, reopens each with a model-matched resume command for Codex or Claude Code, and verifies the result against ps.
pfr --dry-runWhy It's Useful
A blackout kills every agent session on the machine at once. PFR makes bringing the fleet back a repeatable procedure: discovery is frozen into a plan, pfr --dry-run previews it, and you can reopen every session or just a chosen subset.
Key Features
- Pre-boot mtime crash-cluster detection with scored confidence
- Frozen recovery plans so discovery and reopening are repeatable
- Model-matched resume commands for Codex and Claude Code
- Post-open verification against ps with a JSON report
Tech Stack
Synergies
A single-file Bun CLI that turns public ChatGPT, Gemini, Grok, and Claude share links into clean Markdown plus a static, zero-JavaScript HTML twin. Code fences keep their language tags, citation pills are stripped, and filenames are deterministic slugs that never clobber existing files.
Why It's Useful
Copy-pasting from a share page breaks fenced code blocks, loses language hints, and leaves messy filenames. CSCTF archives a conversation in one command, and --publish-to-gh-pages can push it to a GitHub Pages microsite with a regenerated index.
Key Features
- Multi-provider support (ChatGPT, Claude, Gemini, Grok)
- Dual Markdown + HTML output
- Code block preservation
- Stable slug-based output filenames
Tech Stack
Synergies
Get Started
The fastest way to set up the entire flywheel ecosystem is with ACFS. One command, 30 minutes, and you're ready to go.
curl -fsSL https://raw.githubusercontent.com/Dicklesworthstone/agentic_coding_flywheel_setup/main/install.sh | bash -s -- --yes --mode vibeOr use the step-by-step wizard for guided setup.