Skip to content
Back to search

fork-repository-skill

Take your current agent running in your terminal and fork it N times to smoothly branch your engineering work.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/disler--fork-repository-skill/badge.svg)](/listings/disler--fork-repository-skill)

HTML

<a href="/listings/disler--fork-repository-skill"><img src="/api/listings/disler--fork-repository-skill/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

Copy the `.claude/skills/fork-terminal/` directory to your project's `.claude/skills/` folder, or to `~/.claude/skills/` for personal use across all projects.

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 198 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. # Fork Terminal Skill
  2. > A simple skill you can use to fork your agentic coding tools to a new terminal window.
  3. >
  4. > Why? To offload context (delegate), to branch work, to parallelize work, to run the same command against different tools + models, and more.
  5. >
  6. > Check out this [YouTube video](https://youtu.be/X2ciJedw2vU) where we build this skill from scratch.
  7. <img src="images/fork-terminal.png" alt="Fork Terminal Skill" width="800">
  8. A [Claude Code](https://docs.anthropic.com/en/docs/claude-code) skill that enables AI agents to spawn new terminal windows on demand. This skill extends Claude Code's capabilities to launch additional terminal sessions—including other AI coding assistants like Claude Code, Codex CLI, and Gemini CLI—in parallel terminals.
  9. ## Requirements
  10. - [Claude Code](https://docs.anthropic.com/en/docs/claude-code)
  11. - [Gemini CLI](https://github.com/google-gemini/gemini-cli)
  12. - [Codex CLI](https://github.com/openai/codex)
  13. ## What is a Claude Code Skill?
  14. Claude Code skills are **modular, context-aware capabilities** that extend what Claude can do. Unlike slash commands (which require explicit `/command` invocation), skills are **automatically discovered and invoked** by Claude when user requests match the skill's description.
  15. Skills live in `.claude/skills/` directories and consist of:
  16. - A `SKILL.md` file defining triggers, instructions, and workflow
  17. - Supporting files (scripts, templates, documentation)
  18. When you say something like "fork terminal to run tests with Claude Code", Claude automatically detects the matching skill, reads the instructions, and executes the workflow.
  19. ## Purpose
  20. This skill allows you to:
  21. - **Spawn parallel AI agents** in separate terminal windows
  22. - **Run raw CLI commands** in new terminals
  23. - **Pass conversation context** to forked agents (summary mode)
  24. This is useful when you want Claude to delegate work to another agent running independently, or when you need to run long-running commands in a separate terminal.
  25. ## Supported Tools
  26. | Tool | Trigger Examples | Default Model |
  27. | --------------- | ------------------------------------- | ---------------------- |
  28. | **Claude Code** | "fork terminal use claude code to..." | `opus` |
  29. | **Codex CLI** | "fork terminal use codex to..." | `gpt-5.1-codex-max` |
  30. | **Gemini CLI** | "fork terminal use gemini to..." | `gemini-3-pro-preview` |
  31. | **Raw CLI** | "fork terminal run ffmpeg..." | N/A |
  32. ### Model Modifiers
  33. Each agentic tool supports model selection:
  34. - **Default**: Uses the tool's default model
  35. - **"fast"**: Uses a lighter, faster model (e.g., `haiku`, `gpt-5.1-codex-mini`, `gemini-2.5-flash`)
  36. - **"heavy"**: Uses the most capable model
  37. ## Usage Examples
  38. ### Examples you can run NOW
  39. These examples work against this codebase. Generated files go to `temp/`.
  40. **Claude Code**
  41. ```
  42. # Analyze the skill architecture and save a report
  43. "fork terminal use claude code to analyze SKILL.md and write a summary to temp/skill-analysis.md"
  44. # Add Linux support to fork_terminal.py
  45. "fork terminal use claude code to add Linux support to tools/fork_terminal.py, save changes to temp/fork_terminal_linux.py"
  46. # Generate documentation for the Python tool
  47. "fork terminal use claude code fast to read tools/fork_terminal.py and generate docstrings, save to temp/fork_terminal_documented.py"
  48. ```
  49. **Codex CLI**
  50. ```
  51. # Review the cookbook structure
  52. "fork terminal use codex to review cookbook/*.md and write suggestions to temp/codex-cookbook-review.md"
  53. # Generate a test file for the fork tool
  54. "fork terminal use codex to read tools/fork_terminal.py and generate pytest tests, save to temp/test_fork_terminal.py"
  55. # Analyze the SKILL.md workflow
  56. "fork terminal use codex fast to analyze SKILL.md and explain the workflow in temp/workflow-explained.md"
  57. ```
  58. **Gemini CLI**
  59. ```
  60. # Document the skill's purpose
  61. "fork terminal use gemini to read README.md and SKILL.md, write a one-pager summary to temp/gemini-summary.md"
  62. # Suggest new cookbook entries
  63. "fork terminal use gemini to review cookbook/ and suggest a new tool integration, save to temp/new-cookbook-idea.md"
  64. # Analyze cross-platform support
  65. "fork terminal use gemini fast to analyze tools/fork_terminal.py and recommend Linux implementation, save to temp/linux-recommendations.md"
  66. ```
  67. **Raw CLI**
  68. ```
  69. # List all skill files
  70. "new terminal: find .claude/skills -name '*.md' | head -20"
  71. # Watch for file changes
  72. "fork terminal: watch -n 2 'ls -la .claude/skills/fork-terminal/'"
  73. ```
  74. **Multi-Agent Combinations**
  75. ```
  76. # Fork all three agents to review different aspects of the codebase
  77. "fork terminal use claude code to review tools/fork_terminal.py and save analysis to temp/claude-tool-review.md,
  78. then fork terminal use codex to review SKILL.md and save analysis to temp/codex-skill-review.md,
  79. then fork terminal use gemini to review cookbook/*.md and save analysis to temp/gemini-cookbook-review.md"
  80. # Race all three agents on the same task
  81. "fork three terminals: claude code, codex, and gemini - each should read README.md and write improvement suggestions to temp/<agent>-readme-suggestions.md"
  82. # Parallel documentation generation
  83. "fork terminal use claude code to document tools/fork_terminal.py to temp/claude-docs.md,
  84. fork terminal use codex to document SKILL.md to temp/codex-docs.md,
  85. fork terminal use gemini to document the cookbook/ files to temp/gemini-docs.md"
  86. ```
  87. **With Conversation Summary (Context Handoff)**
  88. ```
  89. # Hand off your current conversation context to a new Claude Code agent
  90. "fork terminal use claude code to request a new plan in temp/specs/<relevant-name>.md that details a net new cookbook file for a new agentic coding tool, summarize work so far"
  91. # Delegate a subtask with full context to Gemini
  92. "fork terminal use gemini to implement temp/specs/add-linux-support.md that details how to add Linux support to the fork terminal skill, include summary"
  93. ```
  94. ### Examples you can run later
  95. These examples demonstrate usage patterns for other projects.
  96. ```
  97. # Launch Claude Code for a refactor task
  98. "fork terminal use claude code to refactor the auth module"
  99. # Use a faster model for quick fixes
  100. "fork terminal use claude code fast to fix the typo in utils.py"
  101. # Launch Gemini CLI for test generation
  102. "fork terminal use gemini to write tests for the API"
  103. # Run a dev server in a new terminal
  104. "create a new terminal to run npm run dev"
  105. # Hand off context to a new agent
  106. "fork terminal use claude code to implement the feature we discussed, summarize work so far"
  107. ```
  108. ## How It Works
  109. 1. **Trigger Detection**: Claude detects phrases like "fork terminal", "new terminal", or "fork session"
  110. 2. **Cookbook Selection**: Based on the requested tool, Claude reads the appropriate cookbook (e.g., `claude-code.md`)
  111. 3. **Command Construction**: Claude builds the command with proper flags (interactive mode, model selection, permission bypasses)
  112. 4. **Terminal Spawn**: The `fork_terminal.py` script opens a new terminal window and executes the command
  113. ## Architecture
  114. ```
  115. .claude/skills/fork-terminal/
  116. ├── SKILL.md # Skill definition and workflow
  117. ├── cookbook/
  118. │ ├── cli-command.md # Raw CLI instructions
  119. │ ├── claude-code.md # Claude Code agent instructions
  120. │ ├── codex-cli.md # Codex CLI instructions
  121. │ └── gemini-cli.md # Gemini CLI instructions
  122. ├── prompts/
  123. │ └── fork_summary_user_prompt.md # Template for context handoff
  124. └── tools/
  125. └── fork_terminal.py # Cross-platform terminal spawner
  126. ```
  127. ## Platform Support
  128. | Platform | Status | Method |
  129. | ----------- | ------------------- | -------------------------- |
  130. | **macOS** | Supported | AppleScript → Terminal.app |
  131. | **Windows** | Supported | `cmd /k` via `start` |
  132. | **Linux** | Not yet implemented | — |
  133. ## Installation
  134. Copy the `.claude/skills/fork-terminal/` directory to your project's `.claude/skills/` folder, or to `~/.claude/skills/` for personal use across all projects.
  135. ## Improvements
  136. Ideas for future enhancements:
  137. - **Focus spawned windows** - Bring new terminal windows to front automatically, or keep them in background based on user preference
  138. - **More agentic coding tools** - Add cookbooks for OpenCode, and other agentic coding tools.
  139. - **Whatever else you can think of** - Feel free to fork the terminal fork skill and make it your own.
  140. ## Master **Agentic Coding**
  141. > Prepare for the future of software engineering
  142. Learn tactical agentic coding patterns with [Tactical Agentic Coding](https://agenticengineer.com/tactical-agentic-coding?y=frktskl)
  143. Follow the [IndyDevDan YouTube channel](https://www.youtube.com/@indydevdan) to improve your agentic coding advantage.

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.