Finishing a Development Branch
obra/superpowers
Walks the last step of a branch: confirm tests pass, detect the git environment, ask how to integrate, carry out your choice and clean up the worktree.
Protocol for handling ambiguous decisions and missing/conflicting knowledge during code generation, design, and review.
Install Collaborative Judgment
$ npx skills add techygarg/lattice --skill collaborative-judgment -a claude-codeProject install by default; add -g for ~/.claude/skills/.
$ gh skill install techygarg/lattice collaborative-judgment --agent claude-codeProject scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).
$ git clone --depth 1 https://github.com/techygarg/lattice.git skills-src && mkdir -p .claude/skills && cp -r skills-src/skills/collaborative-judgment .claude/skills/collaborative-judgment && rm -rf skills-srcUse ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.
Claude Code skills documentation · loads skills from .claude/skills/
Install the "collaborative-judgment" agent skill from https://github.com/techygarg/lattice/tree/main/skills/collaborative-judgment into .claude/skills/collaborative-judgment/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "collaborative-judgment", then confirm the skill loads.Claude Code copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$skill-installer install https://github.com/techygarg/lattice/tree/main/skills/collaborative-judgmentType this inside Codex. $skill-installer <name> installs a curated skill from openai/skills. The installer writes to $CODEX_HOME/skills (default ~/.codex/skills). Restart Codex if the skill does not show up.
$ npx skills add techygarg/lattice --skill collaborative-judgment -a codexProject install goes to .agents/skills/; add -g for ~/.codex/skills/.
$ gh skill install techygarg/lattice collaborative-judgment --agent codexProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/techygarg/lattice.git skills-src && mkdir -p .agents/skills && cp -r skills-src/skills/collaborative-judgment .agents/skills/collaborative-judgment && rm -rf skills-srcUse ~/.agents/skills/ instead of .agents/skills for a personal install.
Codex skills documentation · loads skills from .agents/skills/
Install the "collaborative-judgment" agent skill from https://github.com/techygarg/lattice/tree/main/skills/collaborative-judgment into .agents/skills/collaborative-judgment/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "collaborative-judgment", then confirm the skill loads.Codex copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ npx skills add techygarg/lattice --skill collaborative-judgment -a cursorProject install goes to .agents/skills/; add -g for ~/.cursor/skills/.
$ gh skill install techygarg/lattice collaborative-judgment --agent cursorProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/techygarg/lattice.git skills-src && mkdir -p .cursor/skills && cp -r skills-src/skills/collaborative-judgment .cursor/skills/collaborative-judgment && rm -rf skills-srcUse ~/.cursor/skills/ instead of .cursor/skills for a personal install.
Cursor skills documentation · loads skills from .cursor/skills/, .agents/skills/, .claude/skills/, .codex/skills/
Install the "collaborative-judgment" agent skill from https://github.com/techygarg/lattice/tree/main/skills/collaborative-judgment into .cursor/skills/collaborative-judgment/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "collaborative-judgment", then confirm the skill loads.Cursor copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ gemini skills install https://github.com/techygarg/lattice.git --path skills/collaborative-judgment--scope user (default) or --scope workspace; --path is the subfolder of the repo that holds the skill; --consent skips the security confirmation prompt.
$ npx skills add techygarg/lattice --skill collaborative-judgment -a gemini-cliProject install goes to .agents/skills/; add -g for ~/.gemini/skills/.
$ gh skill install techygarg/lattice collaborative-judgment --agent gemini-cliProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/techygarg/lattice.git skills-src && mkdir -p .gemini/skills && cp -r skills-src/skills/collaborative-judgment .gemini/skills/collaborative-judgment && rm -rf skills-srcUse ~/.gemini/skills/ instead of .gemini/skills for a personal install, then run /skills reload.
Gemini CLI skills documentation · loads skills from .gemini/skills/, .agents/skills/
Install the "collaborative-judgment" agent skill from https://github.com/techygarg/lattice/tree/main/skills/collaborative-judgment into .gemini/skills/collaborative-judgment/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "collaborative-judgment", then confirm the skill loads.Gemini CLI copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ gh skill install techygarg/lattice collaborative-judgmentInstalls for Copilot at project scope by default; add --scope user for a personal install. Preview a skill first with gh skill preview. Needs GitHub CLI 2.90.0 or later (public preview).
$ npx skills add techygarg/lattice --skill collaborative-judgment -a github-copilotProject install goes to .agents/skills/; add -g for ~/.copilot/skills/.
$ git clone --depth 1 https://github.com/techygarg/lattice.git skills-src && mkdir -p .github/skills && cp -r skills-src/skills/collaborative-judgment .github/skills/collaborative-judgment && rm -rf skills-srcUse ~/.copilot/skills/ instead of .github/skills for a personal install. Commit .github/skills so cloud agent and code review can use it.
GitHub Copilot skills documentation · loads skills from .github/skills/, .claude/skills/, .agents/skills/
Install the "collaborative-judgment" agent skill from https://github.com/techygarg/lattice/tree/main/skills/collaborative-judgment into .github/skills/collaborative-judgment/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "collaborative-judgment", then confirm the skill loads.GitHub Copilot copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ npx skills add techygarg/lattice --skill collaborative-judgment -a opencodeOpenCode documents no install command of its own. Project install goes to .agents/skills/; add -g for ~/.config/opencode/skills/.
$ gh skill install techygarg/lattice collaborative-judgment --agent opencodeProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/techygarg/lattice.git skills-src && mkdir -p .opencode/skills && cp -r skills-src/skills/collaborative-judgment .opencode/skills/collaborative-judgment && rm -rf skills-srcUse ~/.config/opencode/skills/ instead of .opencode/skills for a personal install.
OpenCode skills documentation · loads skills from .opencode/skills/, .claude/skills/, .agents/skills/
Install the "collaborative-judgment" agent skill from https://github.com/techygarg/lattice/tree/main/skills/collaborative-judgment into .opencode/skills/collaborative-judgment/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "collaborative-judgment", then confirm the skill loads.OpenCode copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
Facts
- Skill name
collaborative-judgment- GitHub stars
- 198
- Token cost
- ~1.5k tokens
- SKILL.md length
- 719 words
- Files
- 1
- Skills in repo
- 33
- Repo updated
- First seen
- Licence
- MIT
At a glance
Protocol for handling ambiguous decisions and missing/conflicting knowledge during code generation, design, and review.
- Works in 3 steps: Multiple valid approaches -- a genuine… → No active context resolves it -- user… → Consequences are meaningful -- affects…
- A decision has multiple valid approaches
- SKILL.md covers When to Decide vs When to Ask, Presentation Format, Batching and Resolution, plus 1 more section
- Instructions only: no scripts, shell commands, URLs or credentials in SKILL.md
What it does
Collaborative Judgment is an agent skill from techygarg/lattice. Protocol for handling ambiguous decisions and missing/conflicting knowledge during code generation, design, and review. Ensures AI surfaces genuine judgment calls with structured options and stops on hallucination risk instead of silently assuming. Use when a decision has multiple valid approaches, when facts are missing or contradictory, when the user asks 'what should we do here?', 'is this a judgment call?', 'should I ask about this?', 'am I guessing here?', 'what are the tradeoffs?', or when deciding between…
Its SKILL.md is about 1.5k tokens, which your agent loads only when the skill is triggered. It is a single SKILL.md file with no bundled scripts.
It sits in Development. The repository describes itself as: Install engineering discipline into any AI coding assistant. Composable skills for design, implementation, review, and team standards. Better process, not just better prompts. The licence is MIT.
When your agent uses it
- A decision has multiple valid approaches
- Facts are missing
- The user asks what should we do here?
- Is this a judgment call?
Example prompts
- “what should we do here?”
- “is this a judgment call?”
- “should I ask about this?”
- “/collaborative-judgment”
Workflow steps
3 steps, taken from the first numbered list in SKILL.md.
- Multiple valid approaches -- a genuine fork between reasonable options.
- No active context resolves it -- user instruction, inspected code/artifacts, current evidence, knowledge base, refiner docs, and context…
- Consequences are meaningful -- affects architecture, behavior, or maintainability. Not cosmetic.
What it can do on your machine
Read from SKILL.md and the folder at commit 4d6c35f. 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
No scripts in the folder and no shell commands in SKILL.md.
From the folder's file list and the shell code blocks in SKILL.md.
Network
No URLs in SKILL.md.
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
Collaborative Judgment loads about 1.5k tokens when it runs. Until then it costs about 175 tokens; SKILL.md has 719 words of instructions outside code blocks.
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
Auto-check passed
The automated check found no risky patterns in SKILL.md.
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 techygarg/lattice at commit 4d6c35f, republished under its MIT licence (© techygarg). 719 words, ~1,482 tokens.
Download SKILL.mdSave it as
.claude/skills/collaborative-judgment/SKILL.md (or your agent's skills folder).- name
- collaborative-judgment
- description
- Protocol for handling ambiguous decisions and missing/conflicting knowledge during code generation, design, and review. Ensures AI surfaces genuine judgment calls with structured options and stops on hallucination risk instead of silently assuming. Use when a decision has multiple valid approaches, when facts are missing or contradictory, when the user asks 'what should we do here?', 'is this a judgment call?', 'should I ask about this?', 'am I guessing here?', 'what are the tradeoffs?', or when deciding between two reasonable architectural or design options. Also composed by molecules to define how judgment calls and clarification requests are surfaced and resolved.
Collaborative Judgment
When to Decide vs When to Ask
Most decisions are NOT ambiguous. The AI decides on its own when:
- The rule is clear. An 80-line function doing 5 things violates SRP. A domain entity importing the database breaks the dependency rule. Fix it.
- The project has a documented preference. The knowledge base, refiner docs, or context anchor specify the choice -- follow it. That is not ambiguity; it is documented intent.
- The impact is low. Variable naming, import order, test data -- choose and move on.
- Grounding is solid. You can point to a source: user instruction, inspected code/artifact, failing test/log, knowledge base, refiner doc, context anchor. Never take a repo-specific fact from memory alone.
Surface a decision only when ALL three are true:
- Multiple valid approaches -- a genuine fork between reasonable options.
- No active context resolves it -- user instruction, inspected code/artifacts, current evidence, knowledge base, refiner docs, and context anchor have all been checked. Still unresolved.
- Consequences are meaningful -- affects architecture, behavior, or maintainability. Not cosmetic.
Confidence test: "I considered two or more approaches, and neither is clearly better given this project's context." True → surface. False → decide and move on.
Default to deciding -- but only when grounded. Grounded autonomy ≠ guessing. STOP: If the evidence is thin, missing, or conflicting, do not silently choose.
Stop and inspect / ask when ANY signal fires:
- No grounding -- you cannot cite a source for a project-specific claim.
- Generic priors filling a local gap -- you are about to assume a file path, API shape, config key, data contract, naming convention, or workflow because "projects usually do X."
- A missing fact collapses the answer -- one unresolved fact would make one option clearly right or wrong.
- Conflicting sources -- user instruction, code, docs, tests, logs, or context docs disagree.
- Unfalsifiable assumption -- you cannot say what evidence would prove the current assumption wrong.
If any signal fires, do not invent options just to fit this protocol. Inspect the available evidence first. If it stays unresolved, ask a targeted clarification.
STOP: Conflicting active sources — surface the contradiction and ask. Never pick a winner silently.
Presentation Format
Two formats:
A. Decision needed
Use when multiple grounded options remain:
Decision needed: [one-line description of what's being decided]
Checked: [sources]. Missing/conflicting: [fact]
- Option A: [approach] — [1-line pro], [1-line con]
- Option B: [approach] — [1-line pro], [1-line con]
I lean toward [option] because [one sentence of reasoning].
Two options is the norm. Three is the maximum. No essays.
Show full SKILL.md (308 more words)Show less
B. Clarification needed
Use when the issue is missing/conflicting knowledge, not balanced options:
Clarification needed: [missing fact or contradiction]
Checked: [sources] Missing/conflicting: [exact fact] Need from you: [1–3 targeted questions or a requested artifact] Why it matters: [one sentence]
No fabricated options. Ask only for facts that materially change direction. If the answer is available in the inspected repo/docs/tests, inspect first -- ask the user only when the gap remains.
Batching
Do not interrupt for every judgment call. Collect and surface at natural checkpoints:
- During implementation (code-forge): batch per component. Surface all judgment calls for a component together before presenting its code.
- During design (design-blueprint): surface immediately. Each design level constrains the next -- batching risks cascading misalignment.
- During review (review): note uncertainty inline in the report, with both interpretations.
- Standalone / freeform: batch per logical task segment. Surface all judgment calls once the feature scope is clear -- not one at a time.
- Knowledge gap / conflicting evidence: surface immediately when the next step depends on the missing fact. Do not batch a blocker just to preserve flow.
Escalation signal: a single component producing more than 3 judgment calls means the project needs clearer standards. Suggest running the relevant refiner instead of asking about each one individually.
Resolution
When the user resolves a judgment call or clarification:
- Apply immediately -- implement the choice in the current context.
- Treat it as a commitment -- the chosen option, clarified fact, or conflict resolution is not revisited silently later in the session.
- Suggest persistence -- if the decision applies to similar future situations, suggest capturing it via
framework:context-anchoring(per-feature) or recommend running the relevant refiner (project-wide).
Diminishing Rule
This protocol becomes less active as the project matures:
- First feature: more judgment calls (no documented preferences yet).
- After running refiners: fewer (project standards are documented).
- After several features: rare (context docs and learnings cover most cases).
© techygarg, MIT. 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 skills/collaborative-judgment of techygarg/lattice.
Open the folder on GitHubat commit 4d6c35f
Compare with similar skills
Collaborative Judgment next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.
| Skill | Stars | Used in | Tokens | Auto-check | Licence | Repo updated |
|---|---|---|---|---|---|---|
| Collaborative Judgment this skilltechygarg/lattice | 198 | — | ~1.5k | Automated safety check: Pass | MIT | |
| Finishing a Development Branchobra/superpowers | 296k | 5 repos | ~1.9k | Automated safety check: Pass | MIT | |
| Typescript Advanced Typesrolling-scopes/rsschool-app | 10k | 24 repos | ~4.2k | Automated safety check: Pass | MPL-2.0 | |
| PR Babysitteropeninterpreter/openinterpreter | 69k | 3 repos | ~4.2k | Automated safety check: Pass | Apache-2.0 | |
| Code Review ChecklistshareAI-lab/learn-claude-code | 78k | 5 repos | ~1.1k | Automated safety check: Pass | MIT | |
| Greplooponyx-dot-app/onyx | 32k | 4 repos | ~3.3k | Automated safety check: Pass | MIT |
Similar skills
Typescript Advanced Types
rolling-scopes/rsschool-app
Master TypeScript's advanced type system including generics, conditional types, mapped types, template literals, and utility types for building type-safe applications.
PR Babysitter
openinterpreter/openinterpreter
Watches an open GitHub pull request until it merges, handling review comments, diagnosing CI failures and retrying flaky checks along the way.
Code Review Checklist
shareAI-lab/learn-claude-code
Reviews code against a five-part checklist covering security, correctness, performance, maintainability and testing, and reports findings in a fixed format.
Greploop
onyx-dot-app/onyx
Iteratively improves a PR (GitHub), MR (GitLab), or shelved changelist (Perforce) until Greptile gives it a 5/5 confidence score with zero unresolved comments.
Guidelines
akash-network/node
Behavioral guidelines to reduce common LLM coding mistakes. An agent skill from akash-network/node.
More from techygarg/lattice
All 33 skills in this repoArchitecture Compass
techygarg/lattice
Architectural thinking partner for an existing repository — scans the codebase, conducts a structured interview, agrees on current architectural state and recommended direction, and produces a…
Lattice Init
techygarg/lattice
Guided setup and upgrade-check experience for Lattice projects -- scans the repository, detects existing configuration and outdated conventions, suggests refiners and available upgrades in priority…
Skill Align
techygarg/lattice
Audit and fix all Lattice documentation, README, docs/, PROJECT.md, GitHub issue templates, and CLAUDE.md to ensure they are fully aligned with the current skill inventory.
Skill Validate
techygarg/lattice
Validate any Lattice SKILL.md against all tier conventions — atoms, molecules, and refiners.
Architecture Refiner
techygarg/lattice
Facilitate a structured conversation to define architecture principles for a repository.
Clean Code Refiner
techygarg/lattice
Facilitate a structured conversation to define clean code principles for a repository.
Related
Categories
Questions about Collaborative Judgment
What does Collaborative Judgment do?
Protocol for handling ambiguous decisions and missing/conflicting knowledge during code generation, design, and review. Collaborative Judgment is an agent skill from techygarg/lattice. Protocol for handling ambiguous decisions and missing/conflicting knowledge during code generation, design, and review.
When should I use Collaborative Judgment?
Collaborative Judgment fits situations like: A decision has multiple valid approaches; facts are missing; the user asks what should we do here?; is this a judgment call?.
How do I install Collaborative Judgment in Claude Code?
Run `npx skills add techygarg/lattice --skill collaborative-judgment -a claude-code`. Or copy the skill folder (skills/collaborative-judgment in techygarg/lattice) into .claude/skills/collaborative-judgment in your project. Claude Code loads it when a task matches its description.
How do I install Collaborative Judgment in Codex?
Run `npx skills add techygarg/lattice --skill collaborative-judgment -a codex`. Or copy the skill folder (skills/collaborative-judgment in techygarg/lattice) into .agents/skills/collaborative-judgment in your project. Codex loads it when a task matches its description.
Can I use Collaborative Judgment in Cursor, Gemini CLI or GitHub Copilot?
Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add techygarg/lattice --skill collaborative-judgment -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/collaborative-judgment, .gemini/skills/collaborative-judgment, .github/skills/collaborative-judgment and .opencode/skills/collaborative-judgment in your project.
What does Collaborative Judgment need to run?
SKILL.md names no scripts, command-line tools or credentials: Collaborative Judgment is instructions for the agent only.
Does Collaborative Judgment access the network?
SKILL.md contains no URLs. Any network use would come from the scripts or tools the agent runs. This is read from the text; nothing was executed.
Is Collaborative Judgment safe to install?
Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.
What licence does Collaborative Judgment use?
Collaborative Judgment is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.
How many tokens does Collaborative Judgment use?
About 1.5k tokens (SKILL.md is roughly 5.9k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.
What are the alternatives to Collaborative Judgment?
Skills that share tags, products or a category with Collaborative Judgment: Finishing a Development Branch (obra/superpowers, 296k stars), Typescript Advanced Types (rolling-scopes/rsschool-app, 10k stars), PR Babysitter (openinterpreter/openinterpreter, 69k stars) and Code Review Checklist (shareAI-lab/learn-claude-code, 78k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.
Who maintains Collaborative Judgment?
techygarg (a GitHub user) maintains it in techygarg/lattice, which has 198 GitHub stars. The repository holds 33 skills in this directory. The repository was last updated on October 6, 2026.
Source: techygarg/lattice on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.