• Motivation & Problem: The author built superlite (a Claude Code plugin) to address high latency in existing workflows like superpowers, where human-in-the-loop bottlenecks (8–12 approval gates per feature), serial execution queues, and excessive re-review loops stalled autonomous progress.
• Single Batch Approval: Replaces constant back-and-forth prompts with a single upfront approval phase (sizing the request and asking at most four questions); after initial sign-off, it only pauses for high-risk actions (e.g., destructive operations, security concerns, or pushing directly to main).
• Parallel Task Graph Architecture: Plans features as dependency graphs with strict interface and file boundaries, allowing non-conflicting tasks to build concurrently (peaking at up to 18 simultaneous agents).
• Specialized Multi-Tier Agent Org Chart:
  • Opus: Acts solely as coordinator/planner to dispatch tasks and conduct final reviews; strictly prohibited from writing or editing code.
  • Sonnet: Handles core implementation tasks and package reviews.
  • Haiku: Assigned routine, well-defined mechanical subtasks off the critical path.
  • Fix-Only Agents: Separated into three tiers to resolve review findings based on root-cause complexity without inflating the coordinator's context.
• Enforcement via Code Hooks (Not Prompts): Uses deterministic hooks rather than prompt instructions to restrict behavior—blocking the coordinator from editing files, auto-backgrounding test commands (pytest, npm test) so they don't block planning, and enforcing task-linting before dispatch.
• Auditing & Tracking: Automatically logs agent decisions, rulings, token metrics, wall-clock time, and test outputs under .superlite/ (progress.md, metrics.jsonl, test-summary.json) with soft budget alerts at 70% of the cap.
• Benchmark Results:
  • On a combined static site generator and spreadsheet engine evaluated across 177 hidden tests, superlite finished in 16.1 minutes (zero human interventions, 177/177 passed), outperforming stock superpowers (33.6 min) by 52% and earlier orchestrated setups (23.5 min) by 31%.
  • Drastically compressed execution spread (9.1 min variance vs. 26.4 min on superpowers), delivering significantly higher build predictability.

• Core Benefits of tmux for Agents:
  • Long-running agent sessions stay alive even if the local terminal emulator closes, SSH drops, or the machine sleeps.
  • Multiple agent sessions are grouped cleanly in a single window instead of cluttering OS desktop workspaces.
  • Full scriptability via standard CLI primitives enables any background job, shell function, or cron trigger to interact with running agents without custom APIs.
• Built-in Claude Code Support:
  • Claude Code supports native isolation using claude --worktree --tmux (or --tmux=classic when scripting traditional tmux).
  • While sufficient for a single agent on a single branch, it lacks multi-agent dashboards, programmatic interaction, and status notification capabilities.
• Architecture and Key Primitives:
  • Best practice recommends a session-per-repository naming pattern (e.g., tmux new-session -A -s <repo> -c <path>) with dedicated task windows or tiled panes.
  • Driving agents: tmux send-keys sends text and keystrokes directly to an agent pane (using -l for literal strings and a short delay before Enter to prevent swallowed inputs).
  • Reading output: tmux capture-pane (paired with -J to preserve wrapped lines) extracts terminal context, while pipe-pane streams raw session logs to disk.
• tmux Limitations ("The Ceiling"):
  • Lacks semantic awareness of agent state; an idle agent, an active agent, and an agent stuck waiting for approval all look like silent or running terminal buffers.
  • Screen scraping via regex/ANSI parsing is inherently fragile across CLI agent updates.
  • Scrollback memory grows rapidly across dozens of streaming agents, sessions do not survive machine reboots, and cross-agent communication requires custom lockfiles and plumbing.
• Alternative Dedicated Terminals (crystl):
  • Dedicated agent terminal harnesses address these ceilings with structured turn-by-turn logs, floating prompt/permission cards, cross-session search, and native git worktree orchestration.

Hacker News Discussion

• Value of Terminal Multiplexers:
  • Commenters view tmux and GNU screen as essential career force multipliers for CLI, remote systems, and agent automation.
  • Several developers highlight that combining tmux popups with tools like fzf unlocks incredibly fast, scriptable workflows.
• Alternative Setups and Ergonomics:
  • Some developers moved away from tmux to avoid split-brain keybindings, instead relying on Emacs, Neovim terminal plugins, or tiling window managers (i3, Forge) to manage both GUI and terminal buffers uniformly.
  • Zellij was frequently recommended as a modern, "batteries-included" alternative with friendlier out-of-the-box defaults.
• Agent-Specific Tooling vs. tmux:
  • Dedicated agent managers (like Herdr or desktop AI apps) are gaining traction for managing multi-agent workloads without manual tmux maintenance.
  • However, users noted tradeoffs: newer VC-backed agent orchestrators occasionally crash or risk future monetization changes, whereas tmux remains rock-solid and crash-proof, often serving as the reliable substrate nested underneath higher-level tools.
• Web Page Layout Critiques:
  • Multiple participants complained about the source site's responsive CSS, noting the reading column becomes excessively narrow on wide retina and 1440p displays, making browser reader mode necessary.

• Study Scope & Setup:

  • Evaluated 21 model–harness combinations using 7 models across 3 agent harnesses (Claude Code, Codex CLI, and Pi) on two benchmarks: SWE-bench Lite and Terminal-Bench 2.0.
  • Controlled variables by testing on identical sampled tasks, using native high-effort settings, capping attempts at 100 turns, and normalizing direct API token pricing.

• The "Harness Tax" Phenomenon:

  • Changing the harness has minimal effect on task resolution rate (within ±2% on SWE-bench Lite and ~±5% on Terminal-Bench 2.0), but dramatically alters token expenditure (diverging by up to 2×–5× for identical success rates).
  • This overhead is driven by initial context bloat, verbose system prompts, and heavy tool schemas injected into the context window before work begins.

• Minimalist Harnesses Remain Highly Competitive:

  • Pi, a lightweight open-source harness, proved competitive with or superior to heavy proprietary harnesses in both resolution rate and token efficiency.
  • For example, running Claude Fable 5 resolved ~97%–98% of tasks across both Claude Code and Pi, yet Claude Code cost approximately twice as much ($1.33 vs. $0.67 per attempt).

• First-Party Harness Mismatch:

  • Models do not necessarily perform best inside their creator's native harness.
  • In 9 out of 12 head-to-head comparisons across Anthropic and OpenAI models, third-party or alternative harnesses delivered higher success rates than the model provider's default CLI.

• Core Practical Takeaway:

  • Accepting a coding agent's default harness incurs an unnoticed "harness tax" in the form of inflated API bills or premature subscription rate limits.
  • Agent benchmarking should decouple models from scaffolds, treating harness complexity and tooling architecture as separate empirical engineering trade-offs.

• Remote Feature Flag Dependency: Claude Code (introduced in v2.1.277) implemented AGENTS.md support via an internal agents-md plugin gated behind a remote feature flag (tengu_agents_md_mod), with fallback evaluation defaulting to false.
• Impact of Telemetry Settings: Disabling telemetry (DISABLE_TELEMETRY=1) or nonessential traffic (CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC=1) prevents fetching remote flags, causing Claude Code to quietly ignore local AGENTS.md files without throwing any warning or notice.
• Affected Environments: The issue identically impacts offline enterprise configurations, third-party API gateways, AWS Bedrock, and GCP Vertex AI, where remote telemetry and Anthropic feature flag endpoints cannot be reached.
• Author's Critique: Tying a local disk-read feature to remote network telemetry is counterintuitive, creates silent failures where models appear to disregard repository instructions, and primarily penalizes security- and privacy-conscious users.
• Workaround & Feature Gaps: Adding a single line (@AGENTS.md) inside a local CLAUDE.md bypasses the gate. Additionally, Claude Code still lacks native support for global user-level AGENTS.md files and shared .agents/skills directories.

Hacker News Discussion

• Anthropic Official Response:
  • An Anthropic engineer (mpoteat) clarified that the behavior was an unintended rollout artifact caused by coupling remote kill-switch mechanisms with telemetry/network endpoints.
  • The issue was acknowledged as human error and resolved in version v2.1.281, which decoupled local file reading from telemetry.
• Introduction of "Mods":
  • The engineer revealed that AGENTS.md support was built as an early test of an upcoming extensibility framework for Claude Code called Mods, which introduces function hooks / middleware for deeper customization.
• Documentation & "Claudish" Writing Style Controversy:
  • A significant portion of the discussion critiqued the leaked/draft documentation for Mods, arguing it was filled with dense, esoteric, AI-generated verbiage ("Claudish") and category-theory jargon rather than straightforward technical English.
  • The author of the docs defended the text as personal dictation rather than purely raw LLM output, while others pointed to stylometry detectors and urged Anthropic to use human technical editors.
• Overengineering Concerns:
  • Commenters questioned why a basic local configuration fallback (reading AGENTS.md instead of CLAUDE.md) required an entire modular plugin architecture and remote kill-switch instead of a simple local filename fallback check.

• Overview & Purpose

  • Anthropic launched Claude Code Projects, an always-on coordination agent designed for long-running, multi-session software development initiatives.
  • Moves past isolated prompt sessions by maintaining overarching project context, memory, and task delegation over time.

• Architecture & Workflow ("Threads do the work, Claude directs it")

  • Operates with an AI coordinator acting as a "chief of staff" sitting above individual worker threads.
  • Developers supply natural language instructions to a single conversation; Claude routes tasks to existing threads or spawns new parallel sessions.
  • Each worker thread runs as an isolated cloud session with its own branch and repository copy, capable of spanning multiple repos (e.g., API, web, mobile).
  • Features an Overview panel for attention items and allows developers to supervise and steer individual threads remotely via mobile.

• Persistent Shared Memory & Knowledge

  • Maintains shared operational memory across worker threads to persist architecture decisions, deprecations, release date adjustments, and dependency tracking.
  • Includes a centralized library containing shared artifacts, user files, plugins, and cloud environment settings.
  • Differs from standard Claude Projects: rather than just holding static reference materials for chats, Claude Code Projects coordinate and remember the work being actively executed.

• Execution Environment & Limitations

  • Currently runs cloud-only, enabling work to continue asynchronously when the user goes offline, but cannot yet access local machines or private internal networks.
  • Local execution support is planned for release in the near future.
  • Parallel changes to overlapping files can still produce standard git merge conflicts that require conventional resolution.

• Rollout, Pricing, & Competitive Landscape

  • Rolling out in beta to select Claude Pro and Max subscribers using cloud sessions, with eventual expansion to Team and Enterprise plans.
  • Draws against existing Claude plan quotas with no standalone fee, though running multiple concurrent threads expends usage allowances more rapidly.
  • Represents an industry-wide pivot—alongside OpenAI, GitHub, and Google—from basic code-generation agents to multi-agent orchestration and coordination layers.

• Token Pricing & Cost Mechanics:

  • Cost is driven by inference time across model size, token direction, and prompt caching.
  • Output (decode) tokens cost roughly 5x more than input (prefill) tokens because they require sequential step-by-step generation.
  • Prompt cache hits cost only 0.1x of standard input pricing, while writing to the cache costs up to 2x (billed once per token).

• Protecting the Prompt Cache:

  • Changing models (/model), effort levels (/effort), or switching on fast mode mid-session invalidates cache prefixes and forces a full re-prefill at normal prices.
  • Prompt caches expire after 1 hour on subscription plans (5 minutes by default on API keys unless ENABLE_PROMPT_CACHING_1H=1 is set); running /compact before stepping away is much cheaper while the old context is still warm.
  • Use /rewind instead of /compact to drop recent failed turns without discarding prior cached tokens.

• Controlling Context Growth & Tool Bloat:

  • Direct File References: Use @-mentions (e.g., @utils.ts) on first reference to attach files immediately and avoid separate Read tool calls or search greps.
  • Silencing Command Output: Append quiet flags to frequently run commands (e.g., test runners) or configure them directly in CLAUDE.md to prevent terminal spam from lingering in the context for all subsequent turns.
  • Subagents & Modular Sessions: Offload verbose, one-off tasks (like parsing large logs) to isolated subagents, run /context to remove unnecessary MCP tools, and execute /clear between distinct development tasks.

Hacker News Discussion

• Handoff Skills and Document-Driven Development:

  • Commenters highlight custom skills like /handoff and structured Markdown-based plans as superior alternatives to native /compact.
  • Dumping state, architectural decisions, and checklists into committed project files enables clean session restarts, seamless switching between AI models, and durable project memory.

• Fatigue Over "Token Accounting" & Prompt Engineering:

  • Users express frustration over having to micro-manage cache lifespans, command flags, and session lengths, feeling that agent harnesses should handle cost and memory optimization automatically.
  • Short cache TTLs are noted as punishing workflows where developers step away while the agent computes.

• Tooling Bugs & UI Friction:

  • Community members discuss issues with file @-mentions malfunctioning in the desktop app versus the CLI.
  • Frustrations are voiced over GitHub repository issue bots auto-closing legitimate bug reports as stale.

• Capability vs. Usability Paradox:

  • Opus 5 is objectively more capable and benchmark-competitive than predecessors (Opus 4.7, Opus 4.8, and Fable), yet it feels significantly worse in daily interactive workflows.
  • Prior models were more collaborative—they asked clarifying questions when requirements were ambiguous, verified assumptions, and did not unilaterally alter project plans.

• Need for Constant Babysitting:

  • Opus 5 tends to make bold, unverified assumptions and pushes forward without user confirmation, forcing users to constantly monitor and intervene.

• Underlying Causes:

  • Benchmarking & RLVR Incentives: Benchmark tasks are designed to be self-contained and score single-pass correctness, penalizing models that pause to ask clarifying questions.
  • Autonomy Goals: Frontier labs prioritize training self-directed, self-improving agents designed for autonomous workflows over collaborative ones.
  • Real-World Mismatch: Production software engineering involves implicit constraints and ambiguous context that cannot be fully captured upfront, making clarification-seeking behavior essential.

Hacker News Discussion

• Formulaic Writing & Stylistic Idiosyncrasies:

  • Commenters note repetitive rhetorical patterns in recent post-training (e.g., rephrasing prompts, predictable essay structures, overuse of terms like "load-bearing," and excessive em-dashes).
  • Unlike humans who pick up subtle conversational feedback and adapt, LLMs lack real-time social cues to temper repetitive linguistic mannerisms.

• Agentic Coding Issues & Comment Bloat:

  • Users report runaway verbosity in codebases, such as agents reinforcing verbose comment styles across subagents until comments outnumber code 3:1.
  • Autonomous decision-making without check-ins becomes particularly problematic when distributed across delegated subagents.

• Post-Training and Sycophancy:

  • Several participants attribute these behaviors to post-training optimizations aimed at producing seemingly authoritative or sycophantic responses rather than concise, collaborative assistance.

• Core Highlights & Main Lessons:

  • CLAUDE.md Optimization: Explicitly directing AI to ignore "development cost" prevents it from taking shortcuts and producing buggy code.
  • Automated MR Descriptions with no-mistakes: Shifts away from manual diff review bottlenecks by generating clear, readable MR descriptions (ideal for MR agent squads).
  • Visualizing LLM Output with HTML (lavish & AXI): Visualizing AI responses in HTML rather than reading raw terminal text enables better planning and inline annotation.
  • Terminal-First Workflow & Tools: Transitioning from GUI editors (VS Code) toward Neovim and terminal workflows, while evaluating tmux setups against tools like herdr.

• Referenced Tools & Resources:

  • WezTerm: https://wezterm.org/index.html
  • tmux: https://github.com/tmux/tmux/wiki
  • Neovim: https://neovim.io/
  • npx skills CLI: https://github.com/vercel-labs/skills
  • OpenSuperWhisper: https://github.com/starmel/OpenSuperW...
  • AXI: https://axi.md/
  • lavish: https://github.com/kunchenguid/lavish...
  • no-mistakes: https://github.com/kunchenguid/no-mis...
  • gnhf: https://github.com/kunchenguid/gnhf
  • treehouse: https://github.com/kunchenguid/treehouse
  • firstmate: https://github.com/kunchenguid/firstmate

L8 Principal's Agentic Engineering Workflow — Detailed Summary

• Core Mindset & Shift to "Captain / Engineering Director"

  • Role Transition: Stop acting like a line-by-line developer manually reviewing code diffs, which creates a personal velocity bottleneck. Instead, operate as an Engineering Director/Captain—setting direction, maintaining quality bars, and managing AI agent crewmates.
  • High Velocity Output: Ships 40–50 fully tested, production-ready PRs per day (rather than simple "vibe-coding" demos) by focusing on high-level planning upfront and automated quality validation at the end.
  • Correcting AI Biases: Frontier models naturally overestimate human development time (e.g., estimating days/weeks for a project an agent can build in minutes) because they are trained on human data. Global instructions must explicitly instruct agents not to over-weight development cost in technical decision-making, preventing them from picking low-quality, cheap shortcuts.
  • Bug Reproduction Protocol: Forces agents to reproduce bugs end-to-end (E2E) as a real user would experience them before attempting a fix, rather than relying solely on superficial unit tests.

• Terminal-Centric Flow State

  • Hands-on-Keyboard Discipline: Doing work in the terminal eliminates mouse interaction, preventing context-switching and preserving flow state.
  • Cross-Device Consistency: Allows the exact same development workflow and persistent session setup to run across Mac, Windows, Linux, laptops, and mobile phones.

• Agent Onboarding & Knowledge Architecture

  • Memory Hierarchy:
    • Global Memory (~/.claude/CLAUDE.md / ~/.config/agents/agents.md): Minimal (~27 lines) cross-project personal preferences loaded into every system prompt. Kept strictly concise to avoid unnecessary token burn.
    • Project Memory (CLAUDE.md / agents.md): Captures repository architecture, domain terminology, testing setups, and collective learnings from past errors.
    • Symlinking Strategy: Uses symbolic links to point harness-specific memory files (CLAUDE.md) to generic agent configuration files (agents.md), keeping the setup agent-agnostic.
  • Skills via Progressive Disclosure: Moves conditionally useful instructions (e.g., E2E testing setups) out of memory files into modular skill files. Skills only load a tiny description field into the initial system prompt, fetching full instructions only when invoked.
  • Skill Benchmark Warning: Warns against blindly installing popular internet skills (e.g., highly-starred repositories). Benchmarking shows unverified skills can increase token consumption by 5%+ and degrade task success rates while introducing security/credential risks.

• Prompting, Tooling & Agent Ergonomics

  • Voice-First Input: Uses local voice transcription (3x faster than typing) for complex prompts, reserving manual typing strictly for exact file paths and URLs.
  • Agent Ergonomics (AXI Standard): Replaces standard MCP (Model Context Protocol) servers with specialized CLI tools and design standards optimized for agents. Benchmarks demonstrate that GitHub MCP servers can cost 3x more tokens and double latency compared to CLI-based interfaces.

• Execution, Planning & Automated Quality Assurance

  • Visual Planning (Lavish): Replaces dense terminal text walls during project planning by spinning up interactive, HTML/artifact-based design systems directly in the browser to visualize choices, annotate UI feedback, and log decisions.
  • Adversarial Post-Processing (No Mistakes): Orchestrates an isolated Git worktree pipeline that rebases code on main, resolves merge conflicts, runs an adversarial agent review in a clean context window, executes E2E validation while logging visual evidence (screenshots/video/logs), updates documentation, and babysits the PR through CI/CD merge.
  • Overnight Autonomous Loops (Good Night Have Fun): Runs long-horizon, iterative tasks (e.g., E2E usability testing, test coverage improvement, metric optimization) under precise iteration caps, token limits, and strict stopping conditions without risking quota burn.

• Multi-Agent Scale & First Mate Orchestration

  • Workspace Isolation (Treehouse): Eliminates manual Git worktree creation overhead (git worktree add/remove) by dynamically provisioning and reusing isolated worktree directories for concurrent agent sessions.
  • First Mate Orchestration: Uses a top-level managerial "First Mate" agent to parse complex, multi-repository prompts, break them down into sub-tasks, delegate them across background agent sessions in parallel worktrees, and coordinate issue triaging.

Dedicated Tools & Software Stack

• Terminal Emulator & Shell Setup

  • WezTerm: High-performance, cross-platform (Mac/Windows/Linux) terminal emulator fully configured dynamically via Lua scripts (wezterm.lua).
  • tmux: Terminal multiplexer used to manage multi-pane layouts and background tabs for parallel agent sessions; preserves session state across device connections.

• Code Editor & Voice Inputs

  • Neovim: Modal, keyboard-driven text editor optimized with plugins for fast fuzzy file finding, code searching (ripgrep), and precise navigation.
  • Open Superwhisper: Free, open-source local voice-to-text application running OpenAI Whisper locally on-device. Uses custom initial prompts to recognize technical vocabulary, URLs, and project names cleanly.

• Agent Harnesses

  • Claude Code: Primary agent harness used in the demonstration; noted for out-of-the-box defaults and feature richness.
  • Codeex CLI: Open-source, Rust-based fast CLI agent harness capable of inspecting its own source code for self-debugging.
  • Pi Coding Agent: Minimalist, highly extensible coding agent harness focused on customization.
  • Open Code: Model-agnostic agent harness featuring a smooth Terminal User Interface (TUI) and multi-model integrations.
  • Vercel Skills CLI (npx skills): Command-line tool used to search, install, and manage agent skills across various agent harnesses.

• Author's Open-Source Agent Ecosystem

  • AXI Standard (axi.md): Agent Ergonomics design standards and optimized CLI tooling catalog (e.g., GitHub AXI, Chrome DevTools AXI) designed to minimize token usage and latency.
  • Lavish AXI: Visual artifact and interactive HTML planning editor that replaces text walls in the terminal with rich UI components for concept review and annotation.
  • No Mistakes: Automated CI/PR pipeline that handles isolated worktree rebasing, adversarial code reviews, E2E evidence capture (screenshots/video), doc updates, and PR babysitting.
  • Good Night Have Fun: Autonomous long-running loop runner with customizable token caps, iteration limits, and stop conditions for overnight or heavy iterative work.
  • Treehouse: Automatic Git worktree manager that manages dynamic, reusable workspace directories for parallel agent sessions.
  • First Mate: Managerial meta-agent that accepts high-level natural language instructions, spawns sub-agents across isolated worktrees, and manages multi-task orchestration automatically.

• Overview & System Requirements:
  • Allows independent Claude Code sessions to communicate across local terminals, distinct machines, or web instances.
  • Requires Claude Code v2.1.224 or later running on macOS or Linux (active by default).
  • Driven automatically by Claude using two core tools: ListAgents (for discovery) and SendMessage (for delivery).
• How to Use Cross-Session Messaging:
  • Listing Active Sessions: Use the /list-agents command to inspect reachable local sessions, subagents, and Remote Control peers along with their assigned names.
  • Naming Sessions: Use /rename or launch with --name <name> to give sessions distinct identifiers (otherwise auto-named based on the working directory, e.g., myapp-3f).
  • Sending Messages via Natural Language: Prompt Claude directly—you do not run SendMessage yourself.
    • Example: "Ask the session running in my other terminal whether the migration finished"
    • Example: "Explain what we just did to the session working on the payments API"
  • Interacting Across Machines: Connect sessions using Remote Control to reply across machines or to web sessions (remote instances can receive replies, but cannot initiate new outbound exchanges).
• Inbound Message Controls & Governance:
  • Manage incoming messages using the crossSessionInbound configuration:
    • accept: Automatically delivers inbound messages to Claude.
    • hold: Displays a approval prompt before message delivery.
    • refuse: Rejects and drops incoming messages automatically.
  • Safety Boundaries: Inbound messages arrive as plain text; they cannot execute slash commands, grant permissions, or alter system configurations (CLAUDE.md).

Comprehensive Guide: Local Agentic Coding Workflow & Model Selection

1. Core Workflow Architecture & Mechanics

• Hardware & VRAM Dynamics:

  • Local LLMs run on GPU VRAM (or Unified Memory on Apple Silicon).
  • Exceeding GPU memory overflows data into system RAM, dropping speeds significantly (e.g., from ~120 tokens/sec down to ~20 tokens/sec).
  • Parameter size and context window scale directly with VRAM consumption.

• Quantization & Optimization:

  • Quantization (such as Q4 4-bit) compresses model weights to reduce VRAM requirements by 50-75% with minimal accuracy loss.
  • Mixture of Experts (MoE) architectures load active parameter layers into VRAM while offloading inactive/less critical layers to CPU/RAM.

• Multi-Tiered Tool Infrastructure:

  • LM Studio (Inference Engine): Local runner exposing an OpenAI-compatible API endpoint (/v1) with fine-grained GPU offloading controls.
  • Continue Extension (VS Code): Handles rapid inline autocompletion using small, low-latency models (~1.5B parameters) with response times under 250ms.
  • GitHub Copilot / VS Code Insiders: Integrates local models via Custom OpenAI Endpoints for full agentic codebase modification.
  • Pi CLI / Qwen Code (Terminal Agent): Terminal-based open-source harness connecting to local endpoints for repository analysis, multi-file edits, and bug fixing.

2. Recommended Software & Models

• Recommended Software Stack:

  • Host / Engine: LM Studio (for GPU offloading control, quantization loading, and OpenAI API local serving).
  • Code Editor & Autocomplete: VS Code + Continue extension (autocomplete) and VS Code Insiders / GitHub Copilot (custom local agent setup).
  • Terminal Agent Harness: Pi (pi via pi.dev) or Qwen Code CLI for terminal-native, multi-file project execution.

• Recommended Models:

  • For Autocomplete: Qwen 2.5 Coder 1.5B (Q4/Q8). Requires ~1 GB VRAM, ensuring sub-250ms completion latency.
  • For Agentic Coding & Reasoning: Qwen 3.6 35B-A3B (MoE with 3B active parameters) or Qwen 2.5 Coder 32B / 14B (Q4 quantization). Chosen for native tool use (function calling), image/vision capability, and multi-step reasoning.

3. Local Workflow vs. Claude Code Comparison

• Cost & Execution Limits:

  • Local Setup: 100% Free & Unlimited. No per-token costs, API rate limits, or monthly tier restrictions after initial hardware acquisition.
  • Claude Code: Subscription & API-based. Subject to usage caps, monthly plan costs, or per-token API charges for Anthropic models.

• Privacy & Security:

  • Local Setup: Fully air-gapped and 100% private. Source code and context never leave your machine.
  • Claude Code: Cloud-dependent. Prompts, code context, and project files are sent to cloud servers for processing.

• Speed & Performance:

  • Local Setup: Hardware dependent. Fast on small models; larger 30B+ reasoning models run slower on consumer GPUs compared to cloud infrastructure.
  • Claude Code: High speed and throughput powered by managed cloud infrastructure.

• Ecosystem & Provider Flexibility:

  • Local Setup: Vendor Agnostic. Swap open-source models (Qwen, Llama, DeepSeek) seamlessly inside terminal harnesses or VS Code.
  • Claude Code: Locked Ecosystem. Exclusively tied to Anthropic Claude models and API platform.

• Architectural Reasoning:

  • Local Setup: Handles small-to-medium tasks and feature additions well, but smaller local models fall slightly short on massive multi-file refactoring compared to top-tier cloud models.
  • Claude Code: High-level architectural reasoning and multi-file refactoring capabilities out-of-the-box.

• The guide explains how to convert a spare Mac into an always-on environment fully controlled by Claude Code, enabling "computer use" (screenshots, clicking, dragging) safely.
• Running Claude Code with the --dangerously-skip-permissions flag on a primary machine carries inherent risk; isolating it on a dedicated device with no sensitive data mitigates these issues.
• Using actual Mac hardware rather than a container or VM provides the agent access to macOS-exclusive applications and full graphical computer use capabilities (e.g., driving Unity for game development).
• The setup enables remote control of the agent from a phone via the Claude app or over SSH from a primary Mac.

Hacker News Discussion

• Alternative Sandbox Environments: A prominent subset of users argued that dedicated physical hardware is largely unnecessary for agent isolation unless specific graphics/Unity workflows are needed. Commenters shared alternative workflows, such as utilizing libvirt to spin up disposable Linux graphical desktops with Full Root, utilizing simple unprivileged accounts (useradd agent), or using lightweight cross-platform engines like smolvm for egress filtering.
• Mobile Use Cases and "Vibe Coding": Several power users highlighted that they now bypass traditional IDEs entirely, relying on Claude Code running 24/7 on remote nodes to queue up background analytical workflows, conduct fuzzing protocols, or triage real-time on-call alerts (e.g., checking Datadog/Cloud logs) directly from their phones during weekend transits.
• Context Window and Token Expense: Users engaged in long-running jobs noted a major limitation: keeping active sessions open for hours results in frequent cache misses on large codebases (500k+ tokens), causing token consumption to escalate quickly. Deleting or recycling sessions periodically is recommended by Anthropic to manage costs.
• Criticism of Scripted/AI-Generated Content: A few commenters expressed fatigue over the setup guide itself, complaining that the underlying shell scripts felt bloated and heavily AI-generated, making the logic overly dense to review or maintain.

• The author, a designer at Jane Street, now primarily uses Claude Code rather than Figma to design and prototype new features.
• Instead of creating traditional spec documents, Figma mockups, and proposals, the new workflow involves writing a problem description, opening an editor, and using Claude to build an interactive prototype inside the actual codebase.
• Building high-fidelity prototypes directly in the medium (e.g., using OCaml and Bonsai at Jane Street) eliminates intermediary artifacts and allows the author to quickly iterate on minute details like keyboard shortcuts, copy, and button refinement.
• This approach makes evaluating concepts much easier for stakeholders, as they can interact with a live tool rather than static frames, which is particularly valuable when testing the feasibility of complex features like internal LLM integration.
• A key shift in their model happened over the course of a few months as improved models, growing prompting familiarity, and proper scoping allowed for handling large-scale diffs (exceeding 2,000 lines).
• A major workflow challenge is how engineering teammates handle code reviews for fully baked features; the current solution treats the prototypes like "code mockups" that engineers can iterate on or reference to write the official production code.
• The author expresses concern that relying on Claude might stifle fluid, out-of-the-box creativity, locking them into an incremental, iterative mindset constrained by what they expect the LLM can easily generate.

Hacker News Discussion

• The Shift from Static Design to Working Prototypes: Many users echoed the author's sentiment, noting that the traditional reliance on Figma for initial product concepts is declining. Teams increasingly prefer building quick, functional wireframes in dev environments that stakeholders can actually interact with.
• Organizational Friction and "Vibe Coding" Pressure: A prominent topic of discussion was the tension this workflow introduces with management and business teams. When non-technical stakeholders or designers build a working prototype quickly using AI ("vibe coding"), leadership often pressures engineers to push it directly to production without understanding the need for refactoring, architecture, and handling edge cases.
• Loss of Deep Design Thinking: Some commenters argued that outsourcing early-stage creation to an LLM removes a crucial phase of critical thinking. Because the AI automatically paints over gaps or details in a prompt, team members stop asking foundational questions ("how should we communicate this idea?" or "what happens when..."), leaving critical logic gaps to be fixed much later.
• Homogenized and "Safe" Aesthetics: Users iterating with text-to-UI tools noted that the default visual output tends to adhere strongly to contemporary web tropes, resulting in boilerplate or generic Tailwind/Bootstrap-style layouts unless heavily prompted with highly specific design rules or unconventional examples.
• The Long Tail of Accountability: Engineers emphasized that while AI dramatically speeds up the initial prototyping loop, it does not replace the necessity for engineering discipline. The long-term ownership of operational risk, system maintenance, edge-case mitigation, and on-call accountability still relies entirely on human experts.

• Data Logged via Proxy: Over a 90-day period, a developer tracked all Claude Code activity using an HTTP proxy to capture full payloads, token counts, and costs directly interfacing with the Anthropic API.
• The Scale: The dataset spanning this study consists of 430 hours of actual work, 6 million input tokens, and a total spend of $1,340 on API costs.
• The Waste Discovery: Analysis revealed that only 27% of the total tokens processed did actual "productive work." The remaining 73% were consumed by nine hidden, automated inefficiency patterns.
• The Solution: By identifying and resolving these nine patterns—each requiring roughly a 30-second fix—productive token efficiency can be increased from 27% to approximately 65% without changing the underlying model or losing functionality.
• The 9 Major Cost Culprits:
  1. CLAUDE.md Bloat (~14% waste): Large, overly dense, or un-optimized systemic instructions files consume massive, unnecessary overhead tokens on every single interaction. Fix: Compress, aggressively prune rules, or split instructions into context-specific modular files.
  2. Conversation History Re-read (~13% waste): Long chat sessions exponentially multiply costs, as message #30 costs 30 times more than message #1 due to processing the entire accumulated history. Fix: Use a structured context-refresh cadence to summarize and discard older, unnecessary messages without losing the current task state.
  3. Hook Injection (~11% waste): Context injected via automated UserPromptSubmit hooks unnecessarily loads extra code and data into the prompt context for tasks that don't require them. Fix: Replace indiscriminate global hooks with conditional triggers that only attach context when explicit keywords or file types are targeted.
  4. Cache Misses (~10% waste): Expired prompt caches (which have a short 5-minute lifespan) force expensive, full-price re-tokenization of the codebase context when work pauses briefly. Fix: Set up an automated low-cost "keep-alive" ping task every 4 minutes to maintain the prompt cache active during active development blocks.
  5. Skill Loading (~7% waste): Inactive or irrelevant scripts (such as loading complex front-end UI design skills during a pure backend task) create up to 13,500 token overheads per command. Fix: Explicitly disable global skill auto-loading and isolate advanced capabilities to dedicated subdirectories or specific active profiles.
  6. Extended Thinking (~5% waste): Leaving the reasoning engine globally enabled forces Claude to burn 3,000+ reasoning tokens on simple commands (like basic camelCase naming changes) where deep logic is completely unnecessary. Fix: Disable extended thinking globally by default and explicitly toggle it on only for complex architectural or bug-hunting queries.
  7. Git Diff Inflation (~5% waste): Unfiltered or massive git diff outputs being fed into the context window when reviewing changes, rather than targeting specific file modifications. Fix: Configure the workflow to stream only targeted file diffs or summary statistics rather than pulling full repository diff text into active prompts.
  8. Directory Map Re-indexing (~4% waste): Redundant and frequent re-scanning of the entire project directory tree structure instead of utilizing cached file maps. Fix: Adjust system configuration to enforce a strict file-map caching policy that limits full directory re-indexing to manual project structural changes.
  9. File Read Overlap (~4% waste): Repeatedly reading the exact same source files multiple times within a short interaction window because the system lacks a localized, short-term memory of recent file states. Fix: Implement a session-level temporary cache structure that prevents the agent from re-fetching un-mutated target files in consecutive turns.
• Debunked Optimization Myths: Lowering costs by switching to a smaller model (like Claude Haiku) for simple tasks only yields a negligible ~3% cost reduction, while aggressively running the /clear command between every minor task proves to be completely counterproductive.
• Actionable Optimization Script: To automatically detect and patch these specific inefficiencies within a local workspace, the text recommends running a dedicated optimization script shared by the author.

• Core Premise: An Obsidian vault maps perfectly onto a code repository structure. It functions as an implicit graph database where notes act as nodes, wikilinks serve as directed edges, tags categorize subgraphs, and YAML frontmatter defines attributes.
• The Claude Code Solution: Instead of basic autocomplete plugins, users can navigate, search, and manage their knowledge vaults by connecting Anthropic's Claude Code via the terminal command line (cd ~/my-vault && claude).
• The Power of CLAUDE.md: Placing a CLAUDE.md file in the root directory establishes clear instructions, vault context, active projects, formatting rules, and strict negative constraints (e.g., prohibiting modification of templates or automated deleting).
• Integration Tooling Ecosystem:
  • Tier 1: Direct file system integration enhanced by obsidian-skills to natively understand format elements like wikilinks and callouts.
  • Tier 2: Model Context Protocol (MCP) servers like MCPVault or obsidian-mcp-tools for compressed token usage, structured search, and semantic discovery.
  • Tier 3: High-performance engines like TurboVault (Rust-based) for graph operations, multi-hop traversal, and SQL querying.
  • Tier 4: Embedded sidebar plugins (e.g., Claudian, Cortex) for users wanting a unified workspace layout.
• High-ROI Workflows:
  • Automated Backlinking: Scraping daily journal notes to dynamically match and generate links to existing or new entity stubs.
  • Cross-Domain Synthesis: Instructing the AI to exclusively reference personal notes to map structural parallels across seemingly unrelated folders.
  • Vault Maintenance: Identifying disconnected "orphan" notes, repairing broken wikilinks, and generating gap analysis reports to guide future writing.
• Safety Protocols: It is highly recommended to track the entire vault using Git to review changes via diffs, isolate all AI outputs inside a specialized draft directory (_ai-drafts/), and rigidly scope prompts to prevent hallucinated external data injection.

• The Risk of Skill Erosion: The author highlights the danger of automation leading to an engineering skill deficit. Similar to how ORMs or Garbage Collection can distance developers from underlying SQL or memory management, over-relying on AI agents risks creating developers who cannot debug or evaluate AI-generated production code.
• The "Remote Work" Parallel: Drawing an analogy to post-COVID remote work, senior engineers can currently leverage AI effectively because they already possess pre-existing, co-located-style foundational engineering skills. The true challenge lies in how newcomers will develop these baseline skills in an AI-first environment.
• Dual-Track Approach to Coding:
  • Vibe Coding (Internal/Prototypes): For internal productivity tools, quick local prototypes, and automation scripting (e.g., audio manipulation with ffmpeg), the author embraces complete AI delegation, ignoring code quality entirely.
  • Production Engineering: Every single line of AI code shipped to production is reviewed 100%. The author actively aims to write code manually roughly 50% of the time using traditional text editors to maintain sharp, fundamental skills.
• Strategic Leverage of Claude Code:
  • Planning: The author drafts structural plans independently first, then compares them against Claude's suggestions to ensure critical thinking isn't outsourced.
  • Omega Messes: Claude Code is intentionally deployed to write highly isolated, heavily tested components (referred to as Sandi Metz's "Omega Messes") to maximize speed without polluting core architectural layers.
• Reallocating Saved Time: Instead of using a 5x velocity boost to hyper-focus on building a frenzy of unneeded features (which ultimately increases stress and decreases user value), the saved time is strategically spent on deliberate breaks, deep architectural thinking, and vetting the actual product utility.
• Real-World Case Study (Shadow Boxing App): The author details migrating a 5-year-old app from Apple's legacy Speech Synthesis framework to an MP3-based ElevenLabs API approach:
  • Vibe Coded the batch audio processors, silence-removers, and config verification tools.
  • Manually Coded the initial core legacy API refactoring and the user interface layout.
  • Delegated to Claude the tedious edge-case handling for the stateful AudioManager (managing Bluetooth latencies, AirPlay interruptions, Siri, and incoming phone calls).

Using Git Worktrees in Claude Code

• The Vulnerability: Researchers at LayerX discovered that Claude Code—Anthropic’s agentic, terminal-based AI coding tool—can be manipulated into performing offensive cyberattacks by simply editing a project's configuration file.
• The "CLAUDE.md" Attack Vector: Claude Code uses a file named CLAUDE.md to store system prompts and project context. Because the AI views this file as authoritative "truth" for the project, attackers can insert specific instructions to bypass safety guardrails.
• Zero-Code Exploitation: The exploit requires no complex programming or advanced prompt engineering. By adding a few lines of text to CLAUDE.md claiming authorization for a "penetration test," the AI will abandon its refusals and execute malicious tasks.
• Capabilities Unleashed: Once the guardrails are bypassed, Claude Code can autonomously perform:
  • SQL Injection (SQLi): Automatically generating and executing payloads to dump databases.
  • Credential Theft: Harvesting usernames and password hashes via automated CURL requests.
  • Data Exfiltration: Sending sensitive local files to external servers.
• Key Risks:
  • Malicious Public Repos: Users cloning a public repository could unknowingly execute a "poisoned" CLAUDE.md file.
  • Insider Threats: Malicious or compromised employees can silently modify this file in internal repositories, as it is often ignored by security scanners.
• Recommendations:
  • For Anthropic: Implement safety scanning specifically for the CLAUDE.md file and alert users when instructions violate standard AI safety policies.
  • For Developers: Treat CLAUDE.md as executable code rather than harmless documentation. It should be subject to code reviews, access controls, and security auditing.

A skill.md file providing instruction on using Obsidian flavoured markdown. Good idea, a whole bunch of this I could delete, and add in things of how I use inline data labels, and tasks.

Making a local mcp server

Similar good practices as compared to slashcommands. The first one is new and important: defining the trigger conditions well.

available variables (this is diff from the slashcommands it seems).

Trigger types can be on file changes, command, git operations or schedule. So what is doing the monitoring for those triggers?

the json files specifies the triggers for a skill. Which can be a manual command, but also others like file changes. So one could shape any slashcommand as a skill too? To better daisychain them e.g.

Skills have their own folder and are a folder with 2 files and subfolder for scripts. Json for config, prompt for instructions and scripts (shell)

Shown here as project specific, but can be general I suppose.

Comparison w slash commands is a diff in trigger (me typing command or called by AI), simplicity (simple single prompts vs prompts and scripts), use cases (repetitive and smart automation) (repetitive warrants automation too imo)

page describing skills wrt claude code

good practice 5: test across diff scenarions (edge cases too I think) I suppose esp if daisychained into workflows of some type

one can reference outside files in slashcommands. E.g. to rerun test on something (although argument would work too). I see a diff in using a reference files as input, or as object of the command, not explained here though

good practice 4, using reference files

good practice 3, as above

good practice 2, be specific about output format. (meant here is e.g. what specific elements an output should contain / questions adressed.

good practice 1, a single clear thing in a command. This, like similar advices for MCP agents and skills, pushes it to granular level. Meaning you could chain them. Similar usage as deterministic elements in CLI possible I'd say. This makes a command a single function in that sense

slash commands can accepts arguments

slash commands can be project specific and generically available in the respective .claude dirs

overview of what claude code slash commands are

n:: Claudecode as 'the help that is showing up' consistently. This is what I observe too where it is used by individuals overcoming barriers to entry to make their personal tools. I think this may be relevant to understand those that turn to chatbots for advice too.

reading everything during production is not the same as producing it. A mental model of the entire construct is not created. Interesting quote: you no longer have a story in your head about what it is you're doing. No helicopter view. The making is scaffolding for your understanding, and that is being cut out.

The option 'yes to all in this session' provided at every turn is seen by author as darkpattern.

putting y on automatic is certain way to end up with stuff you do not have an overview of or no longer comprehend.

author hated the feeling of being reduced to typing 'y' to questions from Claudecode. Recognisable, like babysitting. I watch output alongside Claudecode in VScode, which helps a bit.

Classic approach: if it works, I have a result, if it doesn't I have hands-on experience with algogens as tech, and can use that elsewhere

Vgl Doug.md

mentions different ways of installing a local set-up for AI. Also mentions much cheeper options than Anthropic, specifically OpenRouter.ai. Does not mention running your own local install on a cloud VPS.

Comparison video of Claude Code using Anthropics cloud models vs local models on a M4 128GB. Still a heavy lift, fans spinning, memory usage almost at full capacity. But it works. Means that for my M1 16GB a smaller model is all that works, and you need to leave room for context loading too. For one-offs like code generation and for interactive in moving contexts there's different needs.

Author gives claudecode persistence by adding two types of logging context

Default ollama context length is 4k. Recommended minimum for websearch, agents and coding tools (like Claude Code or Open code) is 64k. I've seen 128k recommendations for Claude Code

where? and in ollama or claude code? this reads like in claude code

Did this using qwen3-code, but then Claude Code just keeps spinning, even with the smallest prompt. Not sure about the cause (first load of model??)

the local models ollama recommends for use in claudecode - qwen3-code - glm-4.7 - gpt-oss:20b - gpt-oss:120b

ollama can also be used with claude code through their endpoint. This allows to use the open Chinese coding models like qwen3

one can run claude code using local models through the LM Studio endpoint. so that you don't use Claude in the cloud.

llm code environment as claude code alternative.

https://web.archive.org/web/20260125124811/https://elite-ai-assisted-coding.dev/p/working-with-asynchronous-coding-agents Eleanor Berger, August 2025.

on asynchronous coding agents

Claude Code for product managers, w management workflow, writing and pkm. Skilles and plugins

Links w further reading wrt Claude Code and Obsidian. Most of these are links to X. Ugh.

Some tips on her usage of Claude Code. - Put all your work in a folder next to the obsidian folder - to treat skills and commands like functions. Don't ever repeat them. - Install and use git locally to have a commit history. - On each step that you need to correct Claude code, tell it to write down directions or rules to avoid a mistake in the future. - circumvent public API liimits by changing the query slightly, or hit it in parallel

now we're back to terminal, I am still not sure about her set-up.

Speaks of how the purpose is not being faster but gtd with less attention on things you don't want to free up attention for. As long as you keep it away from your own key things I suppose. The periphery of what you pay attention to. The many little side projects on the someday/maybe list, the ones just out of reach. Enticing promise! This is the lure ofc.

There is a terminal plugin for Obsidian that you can connect to Claude Code (apparently). She advices against the Claudian plugin bc it lacks plan mode (i.e. not immediately act)

She feels Claude Code is now a core tool in her workflows

UI? Are we still talking about the terminal? Ah no, she means the desktop version, see [[Claude Code for VSCode - Visual Studio Marketplace]] for the VScode plugin as well.

https://web.archive.org/web/20260125105450/https://www.eleanorkonik.com/p/claude-obsidian-got-a-level-up

[[Eleanor Konik p]] on how her work in Obsidian with Claude Code is changing

VScode claude code plugin. Can I check how this integrates, and why the same isn't happening when I want to work with local models?

Claude Code desktop version documentation

by [[Frank Meeuwsen p]], this is his online training for Claude Cowork (coming)

By [[Frank Meeuwsen p]], ivm #2026/01/30 sessie in Utrecht

Ethan Mollick prompts Claude AI to come up with something that people will pay for and could make $1k/month

(via [[Stephen Downes p]])

• [ ] return

Cloud models got much better stil than local models. Coding agents made a huge difference, with it Claude Code becomes very useful

Author thinks MCP may be a temporary phenomenon as a protocol, mostly bc cli tools like Claude code don't need it. The last sentence, that cli tools already exist that are better than the corresponding MCP servers for those tools, goes back to why vibecode/AI-the-things if there's perfectly good automation already around? I think that MCP may still be useful locally for personal tools though. It helps structure what you want your AI to do.

running claudecode uses quite a bit of tokens, making 200usd/month a good deal for heavy users. I can believe that, also bc the machine doesn't care about the amount of tokens it uses during 'reasoning'. Some things I tried, it went through a whole bunch of steps and pages of scrolling output texts, to end up removing one word from a file. My suspicious half thinks, that if an AI company can influence the amount of tokens you use vibecoding, it will.

yolo mode, lol. If you do it, it feels like a very diff tool, and that is the lure / siren song.

wow, $1bn revenue ClaudeCode, a CLI tool!

bc Claudecode abstracts away the usual commands needed on the CLI. Vgl [[In the BeginningWas the Command Line by Neal Stephenson]]

Claude Code is what led devs to embrace CLI more.

Claude Code (feb 2025) seen by author as most impactful release of 2025.

Anthropic reached $1bn revenue with ClaudeCode within 6 months.

MCP plugin for Obsidian, that works with Claude Code

Claude Code, cli tool

Claude Code plugin for Visual Studio Code