← Item page
Link Triage Explainer · X Article

Every Agentic Engineering Hack I Know

Bottom line: Matt Van Horn’s article is less a list of “AI coding tips” and more a full operating system for agentic work: capture every idea into a plan, let agents do deep research/planning, run many sessions in parallel, feed them voice/transcripts/notes, and build custom skills/CLIs so agents can act in the real world.

Author: Matt Van Horn / @mvanhorn Posted: 2026-06-02 Article title: Every Agentic Engineering Hack I Know (June 2026) Fetched via xurl article.plain_text

Source: https://x.com/mvanhorn/status/2061877533885473181

What the piece argues

The article claims the practical leap is not “better prompts”; it is changing the shape of work around agents. The author’s stack turns vague inputs into durable plan.md files, hands execution to Claude Code/Codex, keeps multiple sessions running, and uses surrounding tools — voice, transcripts, notes, remote control, skills, and custom CLIs — to make agent work continuous.

The strongest pattern for Ananth/Dab: the plan is the checkpoint. When context windows blow up or work pauses, a high-quality plan with acceptance criteria lets a fresh agent continue without restarting the thinking.

Fit for Mission Control

  • High fit: Dab already runs as orchestrator/verifier; this article validates making plans, skills, and agent handoffs explicit.
  • High fit: WhatsApp capture → Notice Board → rich artifact/page → Claude Code execution mirrors his “capture first, plan second” loop.
  • Medium fit: multi-agent/tab execution is useful, but needs guardrails because Pi jobs and Notice Board state can collide.
  • Caution: “dangerously skip permissions” is powerful on a personal Mac but should not be copied blindly to the Pi or shared systems.

The workflow map

1
Capture: screenshots, bug URLs, error text, transcripts, product ideas, or voice dumps become agent input immediately.
↓
2
Plan before work: create a repo-aware or context-aware plan with acceptance criteria, patterns to follow, and files to touch.
↓
3
Execute mechanically: an agent works the plan; the human asks only for TL;DR/ELI5/why-this when needed.
↓
4
Parallelize: keep several sessions/tabs alive — planning, building, debugging, testing, research — and rotate attention.
↓
5
Instrument the environment: give agents memory, notes, transcripts, email/remote-control entry points, skills, and CLIs that let them do repeatable real-world tasks.

The 22 hacks, compressed

1–3. Plan-first everything

  • Create a plan.md the moment an idea appears.
  • Do not necessarily read the whole plan; make the agent do the planning so execution is grounded.
  • For deep non-code work, ask for “a plan for the plan” before asking for the final deliverable.

4–7. Make agents always reachable

  • Use voice because LLMs can tolerate imperfect dictation.
  • Run several cmux/terminal tabs with independent sessions.
  • Make new tabs open directly into Claude/Codex.
  • Enable remote control and email-triggered sessions for phone-to-agent work.

8–10. Reduce friction, add research

  • Use high-permission modes when the machine/context makes that acceptable.
  • Send Codex work through Claude or scripts instead of manually opening the Codex CLI.
  • Run “research before plan” with tools such as last30days so the plan is not generic.

11–14. Feed agents high-signal context

  • Put raw Granola transcripts into the LLM; do not over-clean.
  • Preserve human signal from colleagues/users, not just polished docs.
  • Use video tools when visual artifacts explain better than text.
  • Keep notes as the agent’s knowledge base.

15–18. Turn the environment into leverage

  • Use a Mac mini / remote machine as a persistent work hub.
  • Use proofreading/editor tools before sending plans to humans.
  • Write your own reusable skills.
  • Contribute upstream to projects you rely on; it improves both the tool and your agents’ working surface.

19–22. Real-world ops + honesty

  • Hardware setup matters: keyboard, mic, terminal, and desk shape the workflow.
  • Printing Press-style CLIs let agents do real-life tasks, not only code.
  • Watch for AI psychosis / overidentification with the machine; keep human judgment anchored.
  • The article itself was written using the workflow it describes.

Tool/source map mentioned in the article

ClusterTools / links namedWhy it matters
Planning / agent executionCompound Engineering plugin, Claude Code, Codex, OpenAI Codex IDEFormalizes the plan → work loop; closest analogue to Dab’s plan/delegate/verify posture.
Parallel terminal workcmux, Ghostty, tmux, moshLets multiple agent sessions run in parallel and remain reachable.
Voice + transcriptsMonologue, Wispr Flow, Granola, gooseneck micMakes capture cheap; raw transcripts become high-context agent fuel.
Agent memory / notesObsidian, Bear, Supermemory, last30daysTurns personal history and notes into retrievable planning context.
Agent I/O and automationAgentMail, Printing Press, Agent Cookie, OpenClaw, Paperclip, browser agentsGives agents external input channels and repeatable action interfaces.
Media / human-facing polishHyperFrames, Proof, Camofox, HeyGen HyperframesUseful when the output is a demo, video, or polished human-readable artifact.

What Dab should steal now

  1. Plan artifacts as durable checkpoints: make every substantial Mission Control build/research item own a plan or explainer page before code work.
  2. Voice dump → structured page: treat messy WhatsApp/voice captures as acceptable raw input; Dab’s job is to turn them into a usable artifact.
  3. Skills as operational memory: every repeated Notice Board pattern should become or update a skill/reference, not stay in chat memory.
  4. One agent per workstream: for batches, delegate isolated pages/research tasks to Claude Code workers and keep Dab as PM/verifier.
  5. CLI-first real-world actions: prefer narrow, auditable tools/CLIs over browser clicking when agents need to operate services.

What not to copy blindly

  • YOLO permissions: acceptable only on scoped personal machines with backups and strong repo hygiene; dangerous for Pi cron jobs touching Mission Control state.
  • “Don’t read the plan”: good for speed, but Dab still needs independent verification before committing user-visible changes.
  • Too many parallel agents: useful for independent artifacts; risky for shared files like brain.json unless transaction locks and commit isolation are respected.
  • Tool sprawl: adopt tools only where they reduce Ananth friction or increase agent reliability.

Recommended consumption path for Ananth

  1. Skim the workflow map and the “What Dab should steal now” section first.
  2. If deciding what to operationalize, focus on hacks 1, 3, 7, 10, 11, 14, 17, and 20.
  3. Ignore the hardware/terminal preference details unless they solve a current friction point.
  4. Treat this as a backlog of Dab capability patterns, not a manual reading assignment.

Source notes

This explainer used the X API article payload (tweet.fields=article) because the normal post body only exposes the article card. Public metrics at fetch time: 403 likes, 1,180 bookmarks, 38 reposts, 34 replies, 13 quotes, and 38,438 impressions.

Generated for Mission Control Link Triage. No linked repositories/tools were deeply audited in this pass; names above are treated as article references, not recommendations after independent security review.