Skip to content
Skills Library
AI & agents · Planning

dynamic-workflow-packets

/dynamic-workflow-packets

Plan and run large Codex tasks with compact dynamic workflow packets, risk gates, integration, and verification. Use when the user explicitly asks for dynamic workflows, packets, subagents, swarm, orchestration, long-running audits, multi-track coding/research work, job or client search agent design, migrations, repo-wide reviews, or tasks where independent discovery, implementation, review, and verification tracks would reduce drift.

Licence
MIT
Last repository change
14.10.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
3
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 14.10.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

Plan and run large Codex tasks with compact dynamic workflow packets, risk gates, integration, and verification. Use when the user explicitly asks for dynamic workflows, packets, subagents, swarm, orchestration, long-running audits, multi-track coding/research work, job or client search agent design, migrations, repo-wide reviews, or tasks where independent discovery, implementation, review, and verification tracks would reduce drift.

Original author description

Plan and run large Codex tasks with compact dynamic workflow packets, risk gates, integration, and verification. Use when the user explicitly asks for dynamic workflows, packets, subagents, swarm, orchestration, long-running audits, multi-track coding/research work, job or client search agent design, migrations, repo-wide reviews, or tasks where independent discovery, implementation, review, and verification tracks would reduce drift.

How it works

  1. Decision Rule
  2. Operating Contract
  3. Risk Gates
  4. Workflow Artifact
  5. Packet Template
  6. Domain Patterns
  7. Integration
  8. Verification
  9. Reusable Recipes
Original SKILL.md headings · 187 lines, 788 words
SKILL.md preview
---
name: dynamic-workflow-packets
description: Plan and run large Codex tasks with compact dynamic workflow packets, risk gates, integration, and verification. Use when the user explicitly asks for dynamic workflows, packets, subagents, swarm, orchestration, long-running audits, multi-track coding/research work, job or client search agent design, migrations, repo-wide reviews, or tasks where independent discovery, implementation, review, and verification tracks would reduce drift.
license: MIT
metadata:
  abvx_status: experimental
  abvx_origin: adapted
---

# Dynamic Workflow Packets

Use this skill to coordinate big work without turning small tasks into process overhead.

## Decision Rule

Use packet orchestration when at least two are true:

- The task has independent coding, research, data, UX, security, docs, review, sourcing, or verification tracks.
- A clear success contract would prevent drift.
- The task is risky, broad, expensive, external-facing, or long-running.
- Separate review would likely catch mistakes.
- The workflow pattern may be reused.
- The user explicitly asks for packets, swarm, subagents, dynamic workflow, or orchestration.

If the task is small, do it directly and mention that packet orchestration is unnecessary.

## Operating Contract

1. Restate the goal and success criteria.
2. Identify risks and approval gates before execution.
3. Split only genuinely independent work into packets.
4. Keep critical-path work local; delegate or simulate sidecar work.
5. Use subagents only if available and appropriate. Otherwise simulate packets with isolated notes.
6. Set turn/time/tool budgets and stop rules before any long-running or repeated packet.
7. Integrate results explicitly; never paste raw packet dumps as the final answer.
8. Verify against the original success criteria.
9. Save reusable artifacts only when they will help future work.

## Risk Gates

Ask one clear approval question before:

- deleting, overwriting many files, mass-renaming, force-pushing, or rewriting history,
- deploying, publishing, emailing, messaging, posting, applying to jobs, or mutating external systems,
- running migrations, broad codemods, dependency upgrades, or expensive jobs,
- touching credentials, secrets, billing, production data, user accounts, private customer data, resumes, contacts, or outreach history,
- creating public resources or changing third-party accounts,
- spawning many agents or long-running compute.

If risk is ambiguous, do a read-only inspection, draft the exact action, explain likely effect, then ask.

## Workflow Artifact

Create a local run directory only for substantial tasks:

```text
.workflow/<slug>/
|-- plan.md
|-- state.json
|-- packets/
|-- results/
`-- final-report.md
```

For smaller tasks, keep the packet plan in the chat or a temporary note.

`plan.md` should contain:

```text
Goal:
Success criteria:
Context:
Constraints:
Risks and approvals:
Packets:
Integration policy:
Verification:
Reusable artifacts:
```

For long-running packets, add:

```text
Budgets:
Checkpoint / resume:
Loop detection:
Scheduler or trigger:
Eval / acceptance noise:
```

## Packet Template

Each packet must be bounded and self-contained:

```text
Packet ID:
Objective:
Context:
Sources / files:
Ownership:
Do:
Do not:
Expected output:
Verification:
Risk level:
Status:
```

Good packet types:

- repo discovery,
- API or market research,
- implementation slice,
- tests and fixtures,
- UX/product review,
- security or privacy review,
- job/client sourcing,
- outreach message drafting,
- CRM/data-model design,
- final verification.

For code packets, assign non-overlapping files or modules. Tell workers or simulated packet passes not to revert unrelated changes.

## Domain Patterns

### Coding

Use packets for discovery, implementation, tests, docs, security review, and final verification. Keep edits scoped by module. The parent agent owns final patch quality and runs the checks.

### Agent Harness Work

Use packets for loop design, tool registry, context assembly, memory policy, permission/sandbox review, eval fixtures, observability, and managed-agent deployment boundaries. Keep classifier-based permissions separate from deterministic denial rules.

### Research

Use packets for source discovery, primary-source verification, synthesis, counter-evidence, and final citation review. Track source, date, unit, and uncertainty.

### Job And Client Search

Use packets for market/source mapping, opportunity scoring, profile/resume positioning, outreach drafts, follow-up schedule, CRM schema, and risk/privacy review. External messages, applications, profile changes, and public posting require user approval.

### Long-Running Audits

Use packets for inventory, risk triage, deep dives, fix candidates, verification plan, and final report. Prefer one highest-confidence fix over broad speculative churn.

## Integration

After packets complete, synthesize:

```text
Accepted:
Rejected:
Conflicts:
Decisions:
Final changes:
Verification evidence:
Remaining risks:
Reusable follow-up:
```

If packets disagree, inspect the authoritative source before choosing. Reject outputs that are stale, unsupported, duplicate, unsafe, or outside scope.

For subagents, preserve context isolation: give each packet only its needed files, sources, and constraints. The parent agent owns final synthesis, safety decisions, and user-facing claims.

## Verification

Run the narrowest reliable checks first, then broaden as risk warrants:

- unit, integration, or e2e tests,
- lint, typecheck, build,
- script dry run,
- browser/UI smoke test,
- source citation check,
- migration dry run,
- outreach/privacy review,
- manual checklist for non-code work.
- eval fixture replay or acceptance-noise check for agent harness changes.

Do not call the workflow complete until evidence satisfies the original success criteria. Report skipped checks honestly.

## Reusable Recipes

When a run produces a reusable pattern, save a concise recipe only if useful:

```text
Trigger:
Plan shape:
Packet list:
Approval gates:
Verification checklist:
Known risks:
```

Do not save transcripts, secrets, bulky logs, credentials, private contacts, resumes, or sensitive personal details.
Files in this package (3)
  • SKILL.md 6 KB
  • SKILL_CARD.md 2 KB
  • agents/openai.yaml 1 KB

Versions

The database has no other skills named dynamic-workflow-packets.

Database snapshot: 13.11.2026 · package version f6e480e4d3dd (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100workflow
    Use when a task is too large for turn-by-turn orchestration and should run through the big-task workflow lane: system-wide changes, large migrations, repo-wide audits, high-confidence verification, or tasks explicitly asking to run a workflow. Claude Code uses native dynamic…
  • 100codex-dynamic-workflows
    Design a multi-agent workflow for a complex task when the user requests dynamic orchestration.
  • 100dynamic-workflows
    Orchestrate dozens-to-hundreds of subagents from a script Claude writes (Claude Code Dynamic Workflows, trigger `ultracode`). Use when a task exceeds a single agent's context or needs more than ~4 concurrent workers — large audits, migrations, multi-source research, fan-out…
  • 100dynamic-workflows
    Orchestrate dozens-to-hundreds of subagents from a script Claude writes (Claude Code Dynamic Workflows, trigger `ultracode`). Use when a task exceeds a single agent's context or needs more than ~4 concurrent workers — large audits, migrations, multi-source research, fan-out…
  • 100dynamic-workflow
    Design and orchestrate Claude Code dynamic workflows — the new multi-agent system that fans out 10-100 subagents in parallel with verification. Teaches when to use workflows vs single-agent, how to structure fan-out/fan-in patterns, and how to build verification gates. Use when…
  • 100dynamic-workflows
    Apply a consistent set of orchestration patterns whenever writing or reviewing a Claude Code dynamic workflow script (the Workflow tool — agent/parallel/pipeline/phase/log/workflow/args/budget). Use before authoring any workflow script, when the user says "use a workflow",…

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.