Index of every page on this site: llms.txt
All skills
brianlovin avatar

/workflow

@1a9819e official
by Brian Lovinbrianlovin/agent-config377 stars
33
Run it yourself

Workflow orchestration for complex coding tasks. Use for ANY non-trivial task (3+ steps or architectural decisions) to enforce planning, subagent strategy, self-improvement, verification, elegance, and autonomous bug fixing. Triggers: multi-step implementation, bug fixes, refactoring, architectural changes, or any task requiring structured execution.

Use this Skill: https://skilld.dev/gh/brianlovin/agent-config/workflow

Nothing lands on disk. Nothing to clean up.

Fork this Skill

Edit a local copy. It keeps the author and licence.

SKILL.md

≈91 tokens for metadata: the name and description. ≈591 when used: this file.

Description uses 4.5% of example budget

Before choosing a Skill, your Agent reads its name and description. All available Skills share that space.

  • A shorter description leaves more room for other Skills. This entry exceeds our 1% size suggestion.

In our Claude Code example, all Skill names and descriptions share 8,000 characters. This Skill uses ≈363 characters, or 4.5%.

The 1% threshold is a size suggestion. Longer descriptions can still fit.

Your model, settings, and other Skills decide how much text your Agent can read.

Example settings and source

The example uses a 200k-token context and default Claude Code settings. The count includes the name, description, separators, and when_to_use when present. Codex also counts local file paths.

Skit's source and limits: Codex 0.160.1, Claude Code 2.1.292.

Workflow Orchestration

1. Plan Mode Default

  • Enter plan mode for ANY non-trivial task (3+ steps or architectural decisions)
  • If something goes sideways, STOP and re-plan immediately — don't keep pushing
  • Use plan mode for verification steps, not just building
  • Write detailed specs upfront to reduce ambiguity

2. Subagent Strategy

  • Use subagents liberally to keep main context window clean
  • Offload research, exploration, and parallel analysis to subagents
  • For complex problems, throw more compute at it via subagents
  • One task per subagent for focused execution

3. Self-Improvement Loop

  • After ANY correction from the user: update tasks/lessons.md with the pattern
  • Write rules for yourself that prevent the same mistake
  • Ruthlessly iterate on these lessons until mistake rate drops
  • Review lessons at session start for relevant project

4. Verification Before Done

  • Never mark a task complete without proving it works
  • Diff behavior between main and your changes when relevant
  • Ask yourself: "Would a staff engineer approve this?"
  • Run tests, check logs, demonstrate correctness

5. Demand Elegance (Balanced)

  • For non-trivial changes: pause and ask "is there a more elegant way?"
  • If a fix feels hacky: "Knowing everything I know now, implement the elegant solution"
  • Skip this for simple, obvious fixes — don't over-engineer
  • Challenge your own work before presenting it

6. Autonomous Bug Fixing

  • When given a bug report: just fix it. Don't ask for hand-holding
  • Point at logs, errors, failing tests — then resolve them
  • Zero context switching required from the user
  • Go fix failing CI tests without being told how

Task Management

  1. Plan First: Write plan to tasks/todo.md with checkable items
  2. Verify Plan: Check in before starting implementation
  3. Track Progress: Mark items complete as you go
  4. Explain Changes: High-level summary at each step
  5. Document Results: Add review section to tasks/todo.md
  6. Capture Lessons: Update tasks/lessons.md after corrections

Core Principles

  • Simplicity First: Make every change as simple as possible. Impact minimal code.
  • No Laziness: Find root causes. No temporary fixes. Senior developer standards.
  • Minimal Impact: Changes should only touch what's necessary. Avoid introducing bugs.

Source: SKILL.md on GitHub

Skill behaviors

No rule matched.

skilld matched fixed text patterns in SKILL.md and file names. Patterns miss obfuscated code.

skilld run checks every file with the same patterns. It asks for approval before it loads a Skill with a behavior marked Needs approval.

Third-party checks

No alerts1mo3 checks · Risk SAFE
  • Gen Agent Trust Hub1mo

    The skill establishes a structured workflow for coding tasks, focusing on planning, subagent use, and autonomous bug resolution. It is safe for use, but creates a surface for indirect prompt injection by instructing the agent to process and act upon potentially untrusted external inputs like bug reports and logs.

  • Socket1mo

    No alerts

  • Snyk1mo

    Risk: LOW · No issues

Provenance

Signed by skilld at 1a9819e. This ties the file your Agent reads to that commit on GitHub. It does not review the instructions.

Last checked against GitHub last week.

Dormantupdated 8 months ago

Topics

  • Refactoring
  • workflow
  • planning
  • task-management
  • multi-step
  • verification
  • bug-fixing
  • self-improvement
  • subagents

README badge

README badge for brianlovin/agent-config/workflow

What it does

Orchestrates multi-step coding tasks by enforcing upfront planning, parallel subagent execution, self-correcting lessons, verification before completion, and autonomous bug fixing. Use for any task with 3+ steps, architectural decisions, refactoring, or bug fixes where structured execution reduces context switching and prevents half-baked solutions.

Generated from the current SKILL.md.

Frequently asked

When should I use this workflow skill?
Use it for any non-trivial task with 3 or more steps, architectural decisions, multi-step implementations, bug fixes, refactoring, or any work requiring structured execution and verification.
Does this skill use subagents?
Yes. The workflow encourages delegating research, exploration, and parallel analysis to subagents to keep the main context window clean and throw more compute at complex problems.
What happens if something goes wrong during execution?
Stop immediately and re-plan rather than continuing. The workflow prioritizes pausing to reassess over pushing forward with a failing approach.
Does this skill require creating task files?
Yes. The workflow uses `tasks/todo.md` for planning and progress tracking, and `tasks/lessons.md` to capture patterns and rules learned from corrections.
Will this skill verify my work before marking it complete?
Yes. The workflow mandates proving correctness through diffs, test runs, log checks, and asking whether a staff engineer would approve before considering a task done.

Generated from the current SKILL.md. These answers refresh after source changes.