Agentic Coding Flywheel Setup (ACFS)

A standard ACFS installation provides a complete agentic engineering workstation including:

CLI Tools & Runtimes:

• Terminal: zsh, Oh My Zsh, Powerlevel10k
• Utilities: lsd, bat, ripgrep, fzf, zoxide
• Runtimes: Bun (JavaScript), uv (Python), Rust, and Go

Coding Agents:

• cc: Claude Code
• cod: Codex CLI
• agy: Antigravity CLI

Coordination:

• The Dicklesworthstone stack for agent coordination and memory (NTM).

The ACFS ecosystem is organized into several functional categories. Use the following tool mapping to identify which tool handles specific developer workflows:

Core Tools (Required)

• br, bv: Local-first issue tracker with graph-aware dependencies (see beads_rust.md).
• ms: Knowledge management with hybrid semantic search (see meta_skill.md).

Build & Automation (Optional)

• rch: Remote compilation helper for build offloading (see rch.md).
• wa: Terminal automation and orchestration via WezTerm automata (see wezterm_automata.md).

Research & Knowledge (Optional)

• brenner: Research session manager with hypothesis tracking (see brenner_bot.md).

WezTerm Automata (wa) is a terminal hypervisor designed to coordinate multiple AI coding agents running in WezTerm. It captures pane output in real-time (sub-50ms latency) and uses pattern matching to detect agent state transitions (e.g., rate limits, errors, or task completions).

Core Capabilities:

• Observation: Real-time terminal output capture.
• Pattern Detection: Identifies state changes for agents like Claude Code, Codex CLI, and Gemini CLI.
• Robot Mode: A machine-to-machine API for agent integration.
• Search: Full-text search across all captured sessions.
• Safety: A policy engine with capability gates, rate limiting, and audit trails.

The repository is organized into several key functional areas:

• install.sh: The main entry point for the installer.
• acfs.manifest.yaml: The canonical tool manifest defining the system state.
• apps/web/: The Next.js website and setup wizard.
• packages/: Core logic including the manifest parser/generator and onboard TUI.
• acfs/: Files deployed to the user's home directory (~/.acfs/), including ZSH and Tmux configurations.
• scripts/:
  • lib/: Internal installer libraries (logging, security, user management, etc.).
  • generated/: Scripts auto-generated from the manifest (e.g., install_agents.sh, install_stack.sh).
  • providers/: Step-by-step setup guides for Contabo, OVH, and Hetzner.
• tests/: Integration tests for Ubuntu installations using Docker, QEMU, or real VM factories.

The Agentic Coding Flywheel Setup (ACFS) installs over 30 tools and configures a complete development environment. The stack includes:

• Shell & Environment: Modern shell setup using zsh, oh-my-zsh, and powerlevel10k.
• Language Runtimes: bun, uv/Python, Rust, and Go.
• AI Coding Agents: Three primary agents: Claude Code, Codex CLI, and Antigravity CLI.
• Agent Coordination Tools: NTM, MCP Agent Mail, and SLB.
• Cloud CLIs: Vault, Wrangler, Supabase, and Vercel.
• Developer Utilities: 20+ additional developer tools for orchestration, coordination, and safety.

The br (beads_rust) CLI is a local-first issue tracker for AI-assisted workflows. It uses a JSONL persistence model stored in .beads/issues.jsonl for version control compatibility.

Core Concepts

• Beads: The fundamental unit of work/tasks.
• Hierarchical Relationships: Beads can have parent-child relationships.
• Dependency Tracking: Use link to define blocks or blocked-by relationships.
• Status Lifecycle: open → in_progress → closed.
• Priority Scoring: P1 through P5.
• Bead IDs: Follow the format bd-XXXX (where XXXX is a base-36 identifier).

Vibe coding is a development philosophy focused on directing AI agents to handle implementation details (syntax, boilerplate) while the human focuses on intent, architecture, and quality. It follows a workflow of: Describe → Generate → Verify → Ship → Iterate.

When to use Vibe Coding

• Greenfield development
• Prototyping
• Experimentation
• Learning

When NOT to use Vibe Coding

• Production systems with real users
• Security-critical infrastructure
• Systems involving credentials or secrets
• Long-running servers (use safe mode instead)
• Shared team environments (use coordination tools instead)

FSFS (FrankenSearch) is a hybrid search engine designed for code navigation. It bridges the gap between exact string matching (like grep) and conceptual understanding by combining:

1. BM25 Lexical Matching: Fast, keyword-based retrieval.
2. Semantic Vector Search: Finding conceptually related code based on meaning rather than just exact characters.

This makes it particularly useful for AI agents navigating large, unfamiliar codebases where they need to locate implementations by describing functionality rather than providing exact function names.

SRPS is a system management layer designed to keep workstations responsive during heavy AI agent workloads (e.g., running cargo build, npm install, or parallel process spawning). It prevents system unresponsiveness by automatically managing process priorities.

It consists of two main components:

1. ananicy-cpp: A daemon containing 1700+ rules that automatically deprioritizes resource-intensive processes.
2. sysmoni: A Go-based TUI (Terminal User Interface) used for real-time monitoring of process priorities.

DSR (Doodlestein Self-Releaser) is a CLI tool designed to build, tag, and publish releases locally. It serves as an 'escape hatch' for developers and agents when CI/CD pipelines (like GitHub Actions) are throttled, unavailable, or too slow.

Key Capabilities:

• Local builds and cross-compilation.
• Checksum generation.
• GitHub release creation directly from the terminal.
• Bypassing CI/CD rate limits and queue times.