RAW Agentic Coding: How to Build an Agent Skill from ZERO

TL;DR

Build a reusable agent skill by first defining its purpose, problem, proposed solution, deliverable, and file structure. The demonstrated Fork Terminal skill centers on skill.md, with separate tools, prompts, and cookbook directories for executable capabilities, reusable user prompts, and use-case documentation. Read on to see how this structure supports raw CLI commands and agentic coding sessions without an orchestration framework.

Transcript

What's up engineers? [music] Indydean here. So, I thought it would be cool to take a step back from our normal type of video and [music] kind of go back to the root of this channel where we just sit down and we just build let's write [music] a skill from scratch. I've been building software for over 15 years and I've been building with language mod... Read More

Key Insights

• Planning is the first engineering step because an agent needs a clearly defined end state. Before writing prompts or code, the creator identifies the purpose, problem, proposed solution, concrete deliverable, and file structure that should exist when the session ends.
• A reusable agent skill is a packaged combination of prompts, instructions, documentation, and optional code. It applies the same operating approach to a specific problem repeatedly, allowing an agent to deploy established behavior instead of reconstructing the workflow for every new session.
• The skill.md file is the architectural pivot because the skill's behavior centers on its instructions. It tells the operating agent how the capability works and supports progressive disclosure, letting more specialized information become available when the incoming request requires it.
• The tools directory contains executable capabilities that extend what an agent can do. Its contents may include single-file scripts, command-line utilities, or complete programs, and the demonstrated skill plans to include a Python script for opening and controlling forked terminal sessions.
• The prompts directory stores concrete reusable prompts separately from general instructions. The planned fork-summary file is explicitly a user prompt, not a system prompt, and it summarizes the existing terminal session before handing relevant context to a newly launched coding agent.
• The cookbook directory provides use-case-specific operating documentation. Separate Markdown files describe how to launch raw CLI commands and how to start Gemini CLI, Codex, or Claude Code, allowing the main skill instructions to remain compact while detailed procedures are disclosed selectively.
• The Fork Terminal skill is designed to offload work from an existing agent into new terminal windows. A fork can execute a raw command, move a process into another window, or start a separate coding agent with a summary of the original session's context.
• A proof of concept is the appropriate first milestone because it answers whether the idea can work. The initial goal is to establish the planned structure and functioning workflow, while additional documentation, supported tools, and refinements can be added after the central capability is validated.

Questions & Answers

Q: How do you build a reusable agent skill from scratch?

Begin by defining the purpose, problem, proposed solution, concrete deliverable, and expected file structure. Then organize the skill around skill.md, placing executable capabilities in tools, reusable user prompts in prompts, and use-case documentation in a cookbook. The demonstrated project applies this structure to a Fork Terminal skill.

Q: What files and directories does a reusable agent skill need?

The proposed structure uses skill.md as the central instruction file, a tools directory for executable programs, a prompts directory for reusable prompts, and a cookbook directory for detailed documentation. The Fork Terminal example includes a Python terminal script, a fork-summary user prompt, and guides for raw CLI commands, Gemini CLI, Codex, and Claude Code.

Q: What is the purpose of skill.md in an agent skill?

The skill.md file is the pivot around which the skill is organized. It defines how the operating agent should understand and use the capability while directing it to more specialized resources when needed. This supports progressive disclosure and keeps the central instructions focused.

Q: Why should an agent skill have a tools directory?

A tools directory contains commands that extend the agent's capabilities. It may hold single-file scripts, command-line tools, or complete programs. In this project, it contains a Python script intended to open and control forked terminal sessions.

Q: How does a fork-summary prompt transfer work to another agent?

The fork-summary prompt condenses the relevant context from the current terminal session. That summary is passed into a newly launched coding-agent session so delegated work can continue with the necessary context. It is a reusable user prompt, not a custom system prompt.

Q: What does the cookbook directory do in an agent skill?

The cookbook stores additional documentation organized by use case. For the Fork Terminal skill, separate Markdown files explain raw CLI commands and launching Gemini CLI, Codex, or Claude Code. These details are progressively disclosed when the incoming request requires them.

Q: What can the Fork Terminal agent skill launch?

The skill is designed to start new terminal instances and run either raw CLI commands or separate agentic coding sessions. Transcript examples of raw commands include ffmpeg, G-Cloud, and AWS, while the planned coding-agent targets are Gemini CLI, Codex, and Claude Code.

Q: Why start with a proof of concept for an agent skill?

A proof of concept tests whether the central idea can work before the project is expanded. The initial Fork Terminal milestone focuses on establishing the planned structure and a functioning workflow. More documentation, supported tools, and refinements can follow after that core capability is validated.

Summary & Key Takeaways

• The project begins with engineering fundamentals rather than immediate prompting. The intended deliverable, a reusable Fork Terminal skill, is specified before implementation. Its purpose is to let an executing agent open a new terminal window, offload a process, run a CLI command, or transfer summarized context into another agentic coding session.

• The planned architecture centers on skill.md, which describes how the operating agent should use the skill. Supporting directories separate executable tools, reusable user prompts, and cookbook documentation. This structure keeps the core instructions focused while allowing agents to retrieve detailed guidance for particular commands and coding tools only when relevant.

• The first implementation target is a proof of concept rather than a polished product. The creator manually plans the directory and file structure, then gives that explicit end state to a raw coding agent. This preserves human judgment while using agents to perform implementation work and validate whether the proposed workflow can function.

• The skill is designed to fork work into new terminal sessions. It can start raw commands involving tools or cloud services, or launch new Gemini CLI, Codex, and Claude Code agents. A fork-summary prompt transfers the essential context from the current session so a new agent can continue a delegated task.