collaborative-judgment skill
✓ VerifiedProvides a protocol for agents to identify, surface, and resolve ambiguous decisions or conflicting information during technical tasks.
- GitHub stars
- 211
- Files
- 1
- Last commit
- Oct 24, 2026
- License
- MIT
- Allowed tools
- —
What does the collaborative-judgment skill do?
collaborative-judgment provides a protocol for agents to identify, surface, and resolve ambiguous decisions or conflicting information during technical tasks.
Summary generated from the skill's SKILL.md.
About the collaborative-judgment skill
Developers working on complex code generation, design, or review tasks can use this protocol to prevent AI agents from making silent, incorrect assumptions. It provides a structured framework for an agent to identify when a decision is truly ambiguous versus when it is simply following documented project preferences or clear rules. Instead of guessing when faced with missing or conflicting information, the agent uses this skill to surface genuine judgment calls or request specific clarifications.
An agent should load this skill when it encounters multiple valid architectural approaches, conflicting sources like documentation and code, or when a missing fact would fundamentally change the correct path. The protocol produces structured outputs, such as a decision needed format with up to three grounded options or a clarification needed format for missing facts. It relies on inspecting existing evidence like user instructions, knowledge bases, refiner docs, and context anchors to ensure every suggestion is grounded in reality rather than generic priors.
What an agent can do with it
- 1Resolve architectural design forksAsk the agent to choose between two reasonable design patterns when no project documentation specifies a preference.
- 2Batch decisions during implementationHave the agent collect all necessary design choices for a specific component and present them at once before writing code.
Written from the skill's SKILL.md. Every use case is checked against a quote from it.
How to install the collaborative-judgment skill
Each command copies the skill folder into the client's skills directory. Restart the client or start a new session to load it.Install the collaborative-judgment skill in Plugin
/plugin marketplace add techygarg/lattice /plugin install lattice@lattice
Install the collaborative-judgment skill in Claude Code
~/.claude/skills/collaborative-judgment/SKILL.md
$ npx degit techygarg/lattice/skills/collaborative-judgment ~/.claude/skills/collaborative-judgmentInstall the collaborative-judgment skill in Claude Code (project)
.claude/skills/collaborative-judgment/SKILL.md
$ npx degit techygarg/lattice/skills/collaborative-judgment .claude/skills/collaborative-judgmentInstall the collaborative-judgment skill in Codex
~/.agents/skills/collaborative-judgment/SKILL.md
$ npx degit techygarg/lattice/skills/collaborative-judgment ~/.agents/skills/collaborative-judgmentInstall the collaborative-judgment skill in Gemini CLI
~/.gemini/skills/collaborative-judgment/SKILL.md
$ npx degit techygarg/lattice/skills/collaborative-judgment ~/.gemini/skills/collaborative-judgmentInstall the collaborative-judgment skill in Claude.ai
npx degit techygarg/lattice/skills/collaborative-judgment collaborative-judgment && zip -r collaborative-judgment.zip collaborative-judgment # claude.ai → Customize → Skills → + → Create skill → Upload a skill → collaborative-judgment.zip
Automated checks
Ran Nov 14, 2026Full report →Passed our automated checks. That is not a security audit: read the scripts before you let an agent run them. How checks work
- Source repository linked and reachabletechygarg/lattice/skills/collaborative-judgment is public and reachablegithub.com/techygarg/lattice/tree/HEAD/skills/collaborative- ↗Pass
- Open source license (OSI)MITspdx.org/licenses/MIT.html ↗Pass
- Commit or release in the last yearLast commit 2026-10-24github.com/techygarg/lattice/commits ↗Pass
- No download-and-run or credential theft in scriptsNo scripts in the skill folderPass
- No hidden instructions in SKILL.mdNo override phrases, safeguard switches, credential requests or hidden charactersgithub.com/techygarg/lattice/blob/HEAD/skills/collaborative- ↗Pass
- Pre-approved tools are scopedNo pre-approved tools; the agent asks before using onegithub.com/techygarg/lattice/blob/HEAD/skills/collaborative- ↗Pass
- SKILL.md follows the Agent Skills formatValid name and description; says when to use it; 97 linesgithub.com/techygarg/lattice/blob/HEAD/skills/collaborative- ↗Pass
SKILL.md
View on GitHubCollaborative 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.
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).
Files in this skill
1collaborative-judgment skill questions
How do I install the collaborative-judgment skill in Claude Code?
Run npx degit techygarg/lattice/skills/collaborative-judgment ~/.claude/skills/collaborative-judgment. Claude Code loads skills from ~/.claude/skills (all projects) or .claude/skills (one project) and uses a skill when its description matches the task.
Which clients can use the collaborative-judgment skill?
Any client that reads the Agent Skills format: Claude Code, Codex, Gemini CLI and claude.ai (upload as a ZIP). Scripts in the skill run only where the client allows code execution.
How should an agent handle multiple judgment calls to avoid interrupting the user too often?
Agents should batch judgment calls at natural checkpoints, such as per component during implementation, though design-level calls should be surfaced immediately.