RAW Agentic Coding: ZERO to Agent SKILL

Detailed Summary

Introduction (0:00 - 2:13)

The video introduces a raw, unfiltered devlog focused on building an agent skill from scratch, moving away from polished demos to showcase the real process of agentic coding and prompt engineering. The speaker, IndyDevDan, highlights his 15 years of software development experience and extensive work with language models, emphasizing that skills enable consistent and reusable deployment of prompts and code. The goal is to build a "Fork Terminal" tool, explaining its importance and value as the video progresses. The approach involves using a raw agent and writing prompts by hand, with minimal reliance on existing frameworks, stressing the foundational importance of thinking and planning before coding.

• The video is a raw devlog on building an agent skill from scratch, focusing on agentic coding and prompt engineering.
• Skills allow for consistent and reusable deployment of prompts and code.
• The project is to build a "Fork Terminal" tool.
• The methodology involves using a raw agent and manual prompt writing, prioritizing planning over immediate coding.
• The speaker has 15 years of software development experience and has worked with LLMs since GPT-3.5.

Begin with the End in Mind (2:13 - 9:17)

This section emphasizes the critical importance of starting any engineering work, especially with AI agents, by defining the desired end state and concrete outputs. The speaker illustrates this by physically putting away his laptop and using a notebook for planning. He explains that understanding the purpose, problem, and perceived best solution is crucial. For this project, the deliverable is a new agent skill, and the initial step is to outline its file structure. This includes the skill.md pivot file for progressive disclosure, a tools directory for single-file scripts (like a fork_terminal.py using Astral UV), a prompts directory for user prompts (e.g., fork_summary_user_prompt), and a cookbook for additional, use-case-specific documentation.

• The core principle is to "begin with the end in mind" by defining concrete output structures and deliverables.
• Planning involves understanding the purpose, problem, and perceived best solution.
• The deliverable for this project is a new agent skill.
• The initial file structure includes skill.md (pivot file), tools directory, prompts directory, and cookbook directory.
• The tools directory will house a fork_terminal.py script, leveraging Astral UV for Python tooling.
• The prompts directory will contain a fork_summary_user_prompt.
• The cookbook will provide progressive disclosure for different use cases, such as raw CLI commands, Gemini CLI, Codex CLI, and Claude Code.

Initialize Skill Codebase (9:17 - 26:34)

The speaker initializes the codebase for the "Fork Terminal" skill, creating the directory structure previously planned. He uses Cursor IDE but notes that the UI choice is less important as everything converges on agents. The agent is then tasked with building out the basic file structure, including skill.md, tools/fork_terminal.py, prompts/fork_summary_user_prompt.md, and the cookbook files (cli_command.md, gemini_cli.md, codex_cli.md, claude_code.md). The process highlights "in-loop agentic coding," where the engineer actively guides the agent. The skill.md is then populated with a description, usage conditions, and variables to enable/disable different functionalities. The core fork_terminal.py script is developed to open new terminal windows and execute commands, initially focusing on Mac's osascript and later adding Windows support. The cli_command.md cookbook file is updated to instruct the agent to run --help before executing a command, improving its understanding and performance.

• The codebase is initialized with the planned directory structure using Cursor IDE.
• An agent is used to create the empty files for the skill structure.
• The skill.md file is populated with a description, usage conditions, and flags to enable/disable features like Gemini CLI and raw CLI commands.
• The fork_terminal.py script is developed to open new terminal windows and execute commands, initially demonstrated with osascript on Mac.
• The cli_command.md cookbook file is updated to include instructions for the agent to run --help on a command before execution, enhancing its operational intelligence.
• The process demonstrates "in-loop agentic coding" where the engineer guides the agent step-by-step.
• Debugging and iteration are shown, including correcting file paths and refreshing the Claude Code instance for skill updates.

Agent Files (26:34 - 41:28)

This section focuses on building out the agent-specific cookbook files for Claude Code, Codex CLI, and Gemini CLI. The speaker first demonstrates how to prompt an agent to open a new terminal and run a Claude Code instance with a specific model (Haiku) and prompt. This manual process is then encoded into the claude_code.md cookbook file, including instructions for interactive terminals, model selection (fast, base, heavy), and the --dangerously-skip-permissions flag. The pattern established for Claude Code is then mirrored for Codex CLI and Gemini CLI, with the agent assisting in generating these files. Specific model names (e.g., Gemini 3 Pro Preview, Codeex 5.1 Mini) are provided to the agent for accurate configuration. The importance of ensuring new terminals open in the current working directory is addressed and implemented. The speaker also demonstrates how to use a "prime" command to quickly give an agent context of the entire codebase.

• The process begins by manually prompting an agent to open a new terminal and run a Claude Code instance with specific parameters.
• This successful interaction is then encoded into the claude_code.md cookbook file.
• The claude_code.md includes rules for interactive terminals, model selection (Haiku, Sonnet, Opus), and the --dangerously-skip-permissions flag.
• The agent is then tasked with mirroring this pattern for codex_cli.md and gemini_cli.md.
• Specific model names (e.g., Gemini 3 Pro Preview, Gemini 2.5 Flash, Codeex 5.1 Mini) are provided to the agent for accurate configuration.
• The fork_terminal.py script is updated to ensure new terminals open in the current working directory.
• A "prime" command is introduced to quickly provide an agent with the full context of the codebase.
• The speaker emphasizes the power of forking to scale compute and impact by running multiple agents in parallel.

Forked Summaries (41:28 - 50:20)

The final piece of the "Fork Terminal" skill is implementing conversation summarization for forked contexts. The goal is to create a summary of the current conversation, similar to a compact command, and pass it to a new agent. A fork_summary_user_prompt.md template is created in YAML format, designed for the base agent to fill out and pass to the new fork agent. This template includes the conversation history, a summarized user prompt, and the response summary. The skill.md is updated with a new instruction block for "fork summary user prompts," specifying conditions for when to use this feature (only for agentic coding tools) and how to pass the summarized context. The speaker tests this by generating some conversation history and then invoking the fork session with a summary request. After a minor debugging step (ensuring the agent doesn't directly update the prompt file), the system successfully forks a new agent with a concise, summarized history, demonstrating the ability to effectively fork context windows and enable parallel, context-aware agent operations. The video concludes by reiterating the importance of reusable prompts and code, the core four primitives (context, model, prompt, tools), and the value of this raw devlog format.

• The final feature is conversation summarization for forked contexts.
• A fork_summary_user_prompt.md template is created in YAML format to structure the summarized conversation.
• This template allows the base agent to fill in conversation history and pass it to a new fork agent.
• The skill.md is updated with instructions for using the fork summary, specifically for agentic coding tools.
• The process is tested by creating conversation history and then requesting a forked session with a summary.
• A debugging step clarifies that the agent should read and use the template, not update the file directly.
• The system successfully forks a new agent with a summarized conversation history, demonstrating effective context window forking.
• The speaker emphasizes the power of reusable prompts and code, and the importance of understanding the core primitives (context, model, prompt, tools).

Notable Quotes

"Skills let you deploy prompts and code against any problem in a consistent, reusable way." — IndyDevDan

"We never start by just blasting out prompts. We start by thinking through the problem we're trying to solve." — IndyDevDan

"If you don't begin with the end in mind, if you don't actually fully understand what you want to see." — IndyDevDan

"The prompt is the fundamental unit of knowledge work in the generative AI age." — IndyDevDan

"Don't assume that it's the model's fault. First assume it's your fault and then if you really prompt engineer properly, then you can assume it's the tooling's fault." — IndyDevDan

"The limitation is not the models. It's not the agents, it's you and I, right? It's what we're doing with these tools." — IndyDevDan