Core orchestration guidelines for conversation style, code style, testing, tool conventions, and workflow automation

version
1.42.0
GitHub stars
20

Install

/plugin install orchestration@motlin-claude-code-plugins

Run it inside Claude Code after adding the marketplace with /plugin marketplace add motlin/claude-code-plugins.

Contents

Discovered from source

Skills 5

Conversation Style

  • If the user asks a question, only answer it; don't edit code.
  • If the user says to read something, read it and report what it says; don't act on it.
  • If the user asks what a document says, show the relevant section instead of paraphrasing.
  • Judge ideas on their merits and say plainly where they are wrong.
  • Open with the answer, with no praise, apology or preamble.
  • Cut empty intensifiers, words that add emphasis without changing meaning:
    • "any" is often unnecessary ("any changes" → "changes")
    • "actually", "really", "genuinely", "truly"
    • "completely", "totally", "fully"
    • "definitely", "certainly", "absolutely" (false confidence)
    • "just", "simply", "merely"
    • Test: remove the word. If the sentence means the same thing, delete it.
  • In AskUserQuestion options, name the actor instead of a bare "I" or "you" ("Claude will tag it" / " will tag it"), so it is clear who does what.

Finish Workflow

If the working tree is clean and there is nothing to verify, report that there is nothing to finish.

Use the caller's prompt as the commit intent. Run every applicable step, in order:

  • Commit with the git:commit skill, distilling the caller's prompt into a single-line message. Commit before precommit because git test run HEAD refuses a dirty tree and tests the committed HEAD.
  • Run the build:precommit skill. Cached successes pass quickly.
  • Rebase with the git:git-rebase skill.
  • Review the committed diff for reuse, quality, and efficiency, and make cleanup changes when warranted.
  • If cleanup changed anything, create a fixup commit for HEAD.
  • Run the build:precommit skill again.

If the work added many tests or the suite got slower, a code:test-speed pass is an option. Judge whether it is warranted and mention it to the user when it is.

LLM Context Guidelines

The .llm/ directory at the root of a git repository holds extra context for LLMs.

  • .llm/ is not tracked. If it has untracked content, make sure it is listed in .git/info/exclude.
  • .llm/todo.md, when present, is the current task list. Use the markdown-tasks:tasks skill for it, and edit it as plans change to keep it in sync.
  • .llm/scratch/ is writable scratch space for temporary files and output, used when the harness provides no session scratchpad directory.
  • Everything else in .llm/ is read-only reference, such as git clones of tools and saved documentation, unless a skill names its own working directory there.

Memory

Skills, commands, agents, and CLAUDE.md files are markdown too. When a lesson is about how one of them behaves, edit that file. Don't write a memory for it.

Find the owner

Before writing a memory, ask which instructions governed the behavior that went wrong:

  • A skill, command, or agent from a plugin: edit its source in the plugin's git repository.
  • A project's CLAUDE.md or AGENTS.md: edit that file.
  • The user's global ~/.claude/CLAUDE.md: edit it, or propose the edit when it is outside the current task.

Keep the fix lean

Add only the rule the correction showed. Leave out lists of examples, destinations, or past decisions that a later session can infer from the files on disk.

  • Skip decisions that happened once, and decisions the session got right on its first guess. A later session will guess right too.
  • Record a convention only when it breaks the obvious default, such as a naming scheme that differs from the rest of the folder.
  • Don't add rationale or "how to apply" sections, and don't expand existing ones to cover new rules.

What still belongs in memory

Write a memory only for a fact that no instruction file owns.

A memory that patches a gap in a skill should be deleted once the skill is fixed.

Skill Guidelines

Most tasks use several of these skills:

SkillWhen to use
code:code-qualityBefore editing code
code:cliWhen running shell commands
build:precommitAfter code changes
git:git-workflowFor all git operations
orchestration:conversation-styleFor response guidelines
orchestration:llm-contextWhen working with .llm/ directories
orchestration:memoryBefore saving a memory
recap:recapBefore ending a turn

Git

Use the git:commit skill to commit, git:conflicts to resolve merge or rebase conflicts, and git:git-rebase to rebase the current branch on upstream.

Temporary files

Write scratch files and temporary output to the session scratchpad directory when the harness provides one, and otherwise to .llm/scratch/. Avoid /tmp and other system temp directories; reading from them triggers permission prompts.

Finishing

Before returning control after a task that changed files or git state, use the orchestration:finish skill.

Sponsors

Details

Marketplace
motlin/claude-code-plugins
Source
plugins/orchestration
Author
Craig Motlin
Category
Productivity

More from motlin/claude-code-plugins

All 30