Skip to content
Back to skills

General Agent

ASecurity

General-purpose agent methodology — discovery-first approach, spawn delegation, handing findings to sub-agents via durable briefing files, and batching independent work into fan-out waves

  • 10 stars
  • 0 votes
  • 0 copies
  • 1 view
  • Added November 13, 2026
ai-agentsrustgo

Security analysis

A100/100

Scanned November 13, 2026

npx -y skills add reliant-labs/forge --skill general-agent --agent claude-code

Installs into .claude/skills of the current project.

Are you the author of General Agent?

Add the live security badge to your README. It updates with every re-scan.

Security grade badge for General Agent
[![Security: A — Skills Directory](https://www.skillsdirectory.com/api/skills/reliant-labs-general-agent/badge)](https://www.skillsdirectory.com/skills/reliant-labs-general-agent)

More formats (shields.io, HTML) on the badges page. Keep it an A: scan every change in CI with Pro.

Download with Pro
SKILL.md
---
name: general-agent
description: General-purpose agent methodology — discovery-first approach, spawn delegation, handing findings to sub-agents via durable briefing files, and batching independent work into fan-out waves
---

# General Agent Methodology

## Core Philosophy

**Discovery-First Approach**: Always understand before acting. Investigate thoroughly, analyze systematically, and plan comprehensively before implementing solutions.

**Quality Over Speed**: Prioritize correctness, maintainability, and best practices. Take time to understand existing patterns and follow project conventions.

**Systematic Problem Solving**: Break complex tasks into manageable phases, document your reasoning, and maintain clear progress tracking.

## Effective Use of Spawn

You have access to the `spawn` tool to delegate work to specialized agents. Use spawn strategically for two key benefits:

**Parallelization**: Spawn multiple agents simultaneously to work on independent subtasks. For example, spawn a researcher to investigate patterns while you continue planning, or spawn multiple researchers to explore different areas of the codebase in parallel.

**Context Preservation**: Spawned agents run in their own thread, preventing large investigation outputs from cluttering your main context. The agent returns a focused summary while detailed findings stay in its thread. This is especially valuable for research tasks that produce verbose output.

When to spawn vs do it yourself:
- **Spawn** for deep dives, broad investigations, or tasks that benefit from specialist focus
- **Do yourself** for quick lookups, simple edits, or when you need immediate back-and-forth iteration

## Handing findings to sub-agents

A sub-agent starts with only the prompt you write. Findings sitting in YOUR context do not reach it. Retyping a digest from memory is lossy and leaves the sub-agent no way to consult the rest, so it re-derives what you already paid for.

- **Write research that feeds later work to a durable file in the repo.** Not `/tmp`, not only a returned summary. Instruct the researching agent to write the file, give it the exact path, and tell it the file must survive: a sub-agent never deletes an artifact its parent may need. Cleanup is the parent's call.
- **Cite that path in every spawn prompt that depends on it, AND inline the handful of facts the agent needs in its first minute.** Path alone fails — the agent may never open it. Inline alone fails — the agent cannot reach the rest.
- **Mark settled facts as settled.** "Trust but verify" buys the sub-agent the same tool calls that discovering it fresh would. State which claims are already verified and must not be re-derived, and name separately what is genuinely open.
- **Name the skills and files already digested into the briefing** so the sub-agent does not reload them.

Test each prompt before sending: could this agent's first three tool calls be replaced by three sentences? If so, write the sentences.

## Fan-out waves

Shared context is written ONCE, before the fan-out — never rediscovered inside each sub-agent.

Batch independent work into a single wave. Before spawning anything, list every task whose file ownership is disjoint and start them together. Spawning two agents, waiting for them to finish, then spawning two more that never depended on the first two serializes work that had no dependency.

Per wave:
1. Produce or refresh the shared briefing file.
2. Give each sub-agent a disjoint file set, as an explicit own / do-not-touch list.
3. Spawn the whole wave in one turn.
4. Hold a later wave only for work that consumes an earlier wave's output.

## Parallelization

Aggressively parallelize independent work. When a task involves changes to multiple files or modules that don't depend on each other, spawn multiple agents to work on them simultaneously rather than doing them sequentially.

Examples of parallelizable work:
- Editing multiple independent files (spawn one agent per file/module)
- Running tests while making changes to unrelated code
- Researching multiple questions at once
- Implementing separate features that don't share state

Look at your task list — if tasks don't have dependencies between them, spawn agents for each and work on them concurrently. This is one of your biggest advantages over a human developer.

**NOTE**: spawning agents is not just good for parallel work, but also to conserve context which yields better results. You should prefer spawning agents over tackling work yourself.

Attribution

Is this your skill, or is something wrong with this listing? Request removal or report an issue. Author removals are honored within 72 hours.

View all in ai-agents →

Comments

Loading comments…

Newsletter

Get the weekly list of safe new skills, and the ones we pulled.