Aakash GuptaAutomate Your Entire Work Life With Claude Code — No Coding Needed
CHAPTERS
Why Claude Code is becoming a “personal operating system” (and why it beats a human assistant)
Aakash introduces Dave Killeen and the central promise: using Claude Code to run a compounding system that automates planning, intelligence, and execution. Dave frames the key benefit as “living files” that get smarter over time and reduce cognitive load.
- •Claude Code’s momentum and why people are building life/work OS’s on top of it
- •Dave’s claim: better than an executive assistant because it never forgets and compounds
- •Core concept: “living” markdown files that improve as you use them
- •How rapid AI progress is changing what’s possible week to week
Live morning workflow: the “daily plan” command that pulls everything together
Dave runs a single command to generate his day plan, pulling data from calendar, goals, meetings, and multiple intel feeds. The emphasis is on minimal manual work: the system gathers, summarizes, and proposes next actions.
- •One morning command produces meetings, priorities, deals needing attention, and messages to send
- •Inputs include calendar, weekly/quarterly goals, meeting notes, and external intel
- •Cron-like automations continuously update the underlying files
- •Daily plan highlights “what’s new, novel, and contrarian” across sources
Tooling stack: Cursor as a friendly front-end + voice-to-text to stay hands-free
They clarify what viewers are seeing (Cursor) and why “everything as markdown” is so AI-friendly. Dave also explains his voice workflow and why he’s moving from Superwhisper to Whisperflow.
- •Cursor is a dev environment used here to browse/edit files; AI can find files so you don’t need to
- •Markdown-first storage improves AI retrieval and editing
- •Voice workflow: Whisperflow vs Superwhisper (modes, app-aware prompts)
- •Practical tip: keep the system malleable—tell the AI what to redact or rewrite
Connecting your world with MCP servers (LinkedIn, CRM, analytics, anything with an API)
Dave explains how MCP is used as an integration layer and guardrails mechanism, often built directly from API docs. The result is a unified workspace where LinkedIn, CRM signals, newsletters, and internal analytics all flow into the same file system.
- •MCP servers act as guardrails and can be created by pointing Claude at API docs
- •Daily plan includes LinkedIn message triage + CRM cross-referencing via tools like PhantomBuster
- •System brings in sales/forecasting, meeting transcripts, and product analytics data
- •Value proposition: data comes to you “on your terms” instead of you context-switching across tools
Making the system explain itself: Dex skills + the X-ray command (Mermaid diagrams)
Dave introduces Dex (his open-source OS layer) and shows how “skills/commands” encapsulate repeatable workflows. The X-ray skill pulls back the curtain on how a command works, including what files it checks and what it generates if missing.
- •Dex contains ~60 skills/commands that trigger repeatable workflows
- •X-ray explains the daily plan workflow and visualizes it with Mermaid diagrams
- •The system checks which intel files exist; if missing, it generates them before planning
- •Meta-learning: using the OS teaches AI fluency by revealing underlying mechanics
Claude Code in terminal vs Cursor: why hooks change everything
Dave distinguishes between demoing in Cursor and getting maximum leverage in Claude Code’s terminal experience. Hooks—especially session start—enable automatic context injection so every new chat starts “pre-primed” with the right constraints and priorities.
- •Cursor is approachable, but Claude Code terminal unlocks hooks not available in Cursor
- •Session start hook injects weekly priorities, projects, learnings, and constraints into new chats
- •Hooks make the system compound and behave more consistently than relying on chat memory alone
- •Strategic note: terminal-first usage yields better long-term compounding
From backlog idea to PRD: generating specs fast, then applying “taste”
They demonstrate turning a ranked backlog item into a full PRD using Dex context, MCP data, and stronger prompting. Dave emphasizes that AI output is abundant—your job is to curate, pressure-test, and steer toward value rather than produce “infinite slop.”
- •Dex backlog ranks ideas (impact, alignment, token efficiency) and can pit AI ideas vs yours
- •Prompting style: push for “10X, delightful, serendipitous” outcomes; emotional prompts can help
- •AI PRDs are stronger when generated inside your contextual OS (vs generic ChatGPT prompts)
- •Product leadership role shifts toward orchestration and taste, not writing every doc manually
Managing PRD overwhelm: a lightweight Kanban + local “Notion-like” UI
To handle the flood of parallel PRDs/agents, Dave shows a locally hosted React UI that organizes cards, scores work, and recommends next steps. He also demonstrates building micro-apps on demand when the workflow becomes painful (editing, annotations, tags).
- •Kanban board tracks shipped/in-flight PRDs and suggests what to do next per card
- •Built in ~3 hours as a local React app; potential Electron/mobile distribution later
- •Annotation/tagging enables chatting with subsets of knowledge (e.g., competitive metrics you tagged)
- •Malleable software mindset: when a workflow breaks, build the missing UI instead of tolerating it
Career planning as part of the OS: the Career MCP server and evidence-based progression
Dave shows how Dex can manage a personal roadmap by collecting feedback and “evidence” from meetings and work artifacts, then mapping it to quarterly/weekly goals. The system identifies gaps (e.g., strategic influence) and keeps career progress aligned with weekly execution.
- •Career MCP server scans for evidence (transcripts, notes, feedback) that accumulates over time
- •Runs skills-gap analysis and a promotion readiness score based on evidence
- •Maps career goals → quarterly goals → weekly plans, highlighting missing weekly activity
- •Weekly planning can auto-suggest course corrections based on detected gaps
Skills vs MCP servers vs hooks: what each does and when to use them
They define the building blocks clearly: skills/commands are workflow “job descriptions,” MCP servers enforce deterministic integrations and formatting, and hooks automate context and learning at key moments in the session lifecycle. The takeaway is to use MCP where consistency matters and hooks where compounding matters.
- •Skills/commands: human-readable step lists for repeatable work; can be inconsistently invoked
- •MCP: tighter guardrails for interacting with tools/services; more deterministic behavior
- •Hooks: triggered at chat lifecycle moments (e.g., session start) to inject context and learnings
- •Example: task creation is better as MCP to enforce consistent structure and linking
Building your own skill live: turning a request into a reusable /command
Dave demonstrates creating a new skill via natural language—no manual coding required. The generated skill file defines inputs, steps, filtering, and output formatting, then becomes callable as a slash command.
- •Natural-language request generates a complete skill definition file
- •Example: weekly “top 10 trending GitHub repos” recommendations for Dex context
- •Skill includes steps for reading source MD files, ranking, and explaining relevance
- •Invocation pattern: use /command (e.g., /repo-radar) to reliably trigger it
Intelligence scanning and compounding memory: why this beats standalone chatbots
Dave details his “intel ingestion” pipeline: YouTube transcripts, newsletters, and Twitter bookmarks are pulled into markdown, clustered, and summarized for novelty and contrarian signal. They contrast this with cloud chat tools where context isn’t transparently stored, linked, and compounding across entities.
- •Automated ingestion: transcripts/newsletters/bookmarks → MD files → clustered digests
- •Daily output focuses on “novel, contrarian, why it matters” rather than raw consumption
- •Living files append to project/person/company pages, creating entity-based memory
- •Difference vs ChatGPT: transparent, queryable, compounding context you control
Hooks deep dive + continuous improvement loop (Dex improve)
Dave explains hook patterns beyond session start, including capturing mistakes and preferences automatically to prevent repeat errors. He also shows “Dex improve,” which scans Claude Code changelogs and community chatter to recommend system upgrades and even offers to implement them.
- •Session hooks as the “guarantor” of context vs relying solely on Claude.md adherence
- •Automated learning: a mistakes file + working preferences file that get injected later
- •Dex improve scans Anthropic updates + Hacker News/Reddit and suggests prioritized upgrades
- •Creates a self-updating OS: discover capability → decide → implement with AI assistance
Getting started + LLM-neutral agent future (Pi/OpenClaw) + hype vs underhype
They walk through onboarding: cloning Dex from GitHub, running /setup, and connecting calendars, meeting tools, and email. Dave then discusses a direction toward LLM-neutral agent harnesses (Pi/OpenClaw) and closes with his view that OpenClaw is simultaneously overhyped and underhyped due to its long-memory, persistent-data implications.
- •Onboarding flow: clone repo, open in Cursor/terminal, run /setup, choose role/goals, connect sources
- •Recommendation: start in Cursor for comfort, move to terminal for hooks; consider nicer terminals like Ghostty
- •Pi/OpenClaw as lightweight agent harnesses enabling “Swiss-neutral” LLM choice and extensibility
- •Biggest beginner mistake: unclear goals—reverse-prompt friction points, be precise, let AI find the path
