Workflow Mastery

What it does

When your agent uses it

• Mentions productivity
• Speed up development

Example prompts

• “productivity”
• “workflow”
• “parallel”
• “/workflow-mastery”

Workflow steps

5 steps, taken from the first numbered list in SKILL.md.

1. 1Parallel over sequential — Run 3-5 Codex sessions simultaneously using git worktrees. Build a feature in one, fix a bug in another, run…
2. 2Plan then execute — For any non-trivial task, start in plan mode, iterate until the plan is bulletproof, then switch to auto-accept. A…
3. 3Verification closes the loop — Give Codex a way to prove its work: dotnet build, dotnet test, get_diagnostics via MCP. This single…
4. 4Automate the repetitive — If you do it more than once a day, make it a hook, a slash command, or a subagent. Pre-allow safe permissions…
5. 5Compound your knowledge — Every correction becomes a rule in MEMORY.md (see self-correction-loop skill). Every PR review adds a learning…

What it can do on your machine

Read from SKILL.md and the folder at commit a31015f. It shows what the files ask for, not the result of running them.

• Tool permissions

  Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

  From allowed-tools in the SKILL.md frontmatter.

• Runs code

  Shell commands in SKILL.md call:

  • dotnet
  • git
  • codex

  From the folder's file list and the shell code blocks in SKILL.md.

• Network

  No URLs in SKILL.md. Its commands use git, which can reach the network depending on how they are called.

  From URLs in SKILL.md, links to its own repository left out.

• Credentials

  Names no API keys, tokens, secrets or passwords.

  From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Workflow Mastery loads about 2.4k tokens when it runs. Until then it costs about 158 tokens; SKILL.md has 659 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it

~158

When it runs · the whole SKILL.md, loaded when a task matches

~2.4k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from Resgrid/Core at commit a31015f, republished under its Apache-2.0 licence (© Resgrid). 659 words, ~2,419 tokens.

name

workflow-mastery

description

Codex workflow mastery for .NET developers. Covers parallel execution with git worktrees, plan mode strategy, verification loops, auto-formatting hooks, permission setup for dotnet CLI, prompting techniques, and subagent patterns — all adapted for the .NET ecosystem. Load this skill when setting up Codex for a .NET project, optimizing workflows, running parallel sessions, or when the user mentions "productivity", "workflow", "parallel", "worktree", "plan mode", "permissions", "hooks", "10x", "setup Codex", or "speed up development". Inspired by tips from Boris Cherny (creator of Codex) and the Anthropic team.

# Create worktrees for parallel work
git worktree add ../my-project-feature origin/main
git worktree add ../my-project-bugfix origin/main
git worktree add ../my-project-tests origin/main

# Start Codex in each (separate terminal tabs)
cd ../my-project-feature && Codex
cd ../my-project-bugfix && Codex
cd ../my-project-tests && Codex

// .Codex/settings.json
{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Write|Edit",
        "hooks": [
          {
            "type": "command",
            "command": "dotnet format --include \"$CLAUDE_FILE_PATH\" --no-restore 2>/dev/null || true"
          }
        ]
      }
    ]
  }
}

{
  "permissions": {
    "allow": [
      "Bash(dotnet build *)",
      "Bash(dotnet test *)",
      "Bash(dotnet run *)",
      "Bash(dotnet ef *)",
      "Bash(dotnet format *)",
      "Bash(dotnet restore *)",
      "Bash(dotnet pack *)",
      "Bash(dotnet tool *)"
    ]
  }
}

Step 1: Enter plan mode (Shift+Tab twice)
Step 2: Describe the task with full context
Step 3: Iterate on the plan — challenge assumptions, ask "what about edge cases?"
Step 4: Once the plan is solid, switch to normal mode
Step 5: Codex executes with auto-accept — often 1-shots the implementation

"Review this plan as a staff .NET engineer. Challenge every assumption.
What could go wrong? What's missing? What would you do differently?"

"Grill me on these changes. Would this pass a staff .NET engineer's code review?
Check for: N+1 queries, missing CancellationToken, exposed domain entities,
missing validation, incorrect service lifetimes."

"Prove this works. Run the tests, show me the output.
Then diff the API response between main and this branch."

"Knowing everything you know now, scrap this and implement the elegant solution.
No hacks, no workarounds."

"Generate the migration, then show me the raw SQL it produces.
I want to verify the migration before applying it."

<!-- .Codex/agents/verify-api.md -->
You are a .NET API verification agent. Your job:
1. Run `dotnet build` and fix any compilation errors
2. Run `dotnet test` and fix any test failures
3. Use `get_diagnostics` to check for warnings
4. Verify all endpoints return proper TypedResults
5. Check that no domain entities leak into API responses
Report: PASS with summary, or FAIL with specific issues.

<!-- .Codex/agents/code-simplifier.md -->
You are a code simplification agent for .NET projects.
Review the recent changes and simplify:
- Replace verbose LINQ with simpler alternatives
- Use primary constructors where applicable
- Replace manual null checks with pattern matching
- Consolidate duplicated code
- Remove unnecessary using statements
Do not change behavior. Only simplify.

"Run the verify-api agent on my changes before I create the PR."
"Run code-simplifier on the files I just modified."

// BAD — dive straight into a multi-file refactor
"Refactor the Orders module to use DDD with aggregates and value objects"
*Codex modifies 15 files, misses half the invariants, tangles the migration*

// GOOD — plan first, execute after
"Enter plan mode. I want to refactor the Orders module to use DDD.
Let's plan which files change, what the aggregate boundary is,
how value objects map to EF Core, and what the migration strategy is."

// BAD — sequential work in one session
1. Build feature       (20 min)
2. Write tests         (15 min)
3. Fix formatting      (5 min)
4. Update docs         (10 min)
Total: 50 minutes

// GOOD — parallel worktrees
Worktree 1: Build feature     (20 min)
Worktree 2: Write tests       (15 min, started simultaneously)
Worktree 3: Update docs       (10 min, started simultaneously)
Total: ~20 minutes (wall clock)

// BAD — accept mediocre code
Codex: "Here's the implementation" *generic, works but not great*
You: "Looks good, ship it"

// GOOD — push for quality
Codex: "Here's the implementation"
You: "Would a staff .NET engineer approve this?
      What about the service lifetime? Is this N+1 safe?
      Is there a more elegant way using C# 14 features?"

© Resgrid, Apache-2.0. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

Just SKILL.md in .agents/skills/workflow-mastery of Resgrid/Core.

Open the folder on GitHubat commit a31015f