lawve-ai/awesome-legal-skills/ambiguity-report-seth-chandler
Claude Code and agent skill by lawve-ai/awesome-legal-skills
- community
Checking that the SKILL.md file is still in the repository.
Turn an interpretive-ambiguity audit of a legal text — contract, statute, regulation, or judicial opinion — into a polished deliverable. Produces a multi-page website (default), a single-page interactive site, a Microsoft Word document, a PowerPoint deck, or a LaTeX/PDF. Use whenever a user has a stress-test result, ambiguity audit, or "where will this be litigated" scenarios and wants to publish, present, or share them. Triggers on "publish the audit," "make a report from this," "turn this into a website / deck / brief / Word doc," "make a Netlify site," "build slides of these ambiguities," "render the scenarios," "package this stress test," "produce a LaTeX version," and similar. Pairs with the ambiguity-stress-test skill (the underlying analysis) but works on any structured or semi-structured ambiguity analysis. Visual design is opinionated but the user can override colors, fonts, and brand label. Most formats need Python and a writable filesystem; single-file HTML works where the host has neither.
Install
npx vskill@latest install lawve-ai/awesome-legal-skills/ambiguity-report-seth-chandlerSKILL.md
The same SKILL.md was published earlier as lawve-ai/awesome-legal-skills/ambiguity-report-seth-chandler.
Ambiguity Report
Take an interpretive-ambiguity analysis of a legal text and turn it into a polished deliverable in one of six formats: multi-page website (the default), single-page interactive website, single-file HTML, Microsoft Word document, PowerPoint deck, or LaTeX source for a PDF.
Before promising a format, know what this host can do. Four of the six formats have requirements the host may not meet, and discovering that after the spec is built wastes the user's effort. Run the capability check in Stage 3 first.
The skill's central insight: the data is the same across formats, the rendering is not. An ambiguity analysis is a set of scenarios — each with a situation, two opposed positions, a weak point in the text, a likely outcome, and a proposed redraft — anchored to provisions of a source text. Once that data is captured in the canonical spec, the right format follows from how the deliverable will be used.
Workflow
This skill has four stages. Stages 1–3 are setup; stage 4 is rendering.
- Stage 1 — Identify the input. Determine what kind of analysis the user is handing over. Three common shapes: (a) the structured markdown output of the
ambiguity-stress-testskill; (b) a less-formal report or memo with scenarios identified but not all seven canonical fields filled in; (c) raw prose that names some ambiguities but isn't formatted as scenarios at all. The strategy for each shape differs — seeresources/parsing-unstructured.md. - Stage 2 — Build the canonical spec. Convert the input into a structured JSON spec that every renderer can consume. The schema is in
resources/data-format.md. Fill in defaults for missing fields rather than blocking on completeness, and surface to the user what was inferred so they can correct. - Stage 3 — Choose the format and design. Confirm with the user which format they want (default: multi-page website). Capture any design overrides (accent color, fonts, brand label). Most users care only about format and accent color; almost everything else has a sensible default.
- Stage 4 — Render. Delegate to the right renderer. The website and LaTeX paths use the bundled generator scripts (
scripts/generate_site.pyandscripts/generate_latex.py). The Word and PowerPoint paths delegate to the existingdocxandpptxskills with content structured for those formats. Format-specific guidance lives inresources/format-{website,docx,pptx,latex}.md.
Stage 1 — Identify the input
Look at what the user supplied. Three signatures to watch for:
Signature A — structured stress-test output. Markdown with sections titled like "## Scenarios" and individual scenarios under headers like "### S-1 —", each containing labeled fields ("Anchors:", "Defect family:", "Weak point:", "Likely outcome:", "Redraft:"). Often produced by the ambiguity-stress-test skill. This is the easy case — parse directly into the canonical spec.
Signature B — semi-structured report. Numbered ambiguities or issues in prose, each with a paragraph or two of explanation. The seven canonical fields may not all be present — the "situation" and "weak point" might be merged; the redraft might be missing entirely. Extract what's there, flag what's missing, and either infer reasonable defaults or ask the user. See resources/parsing-unstructured.md.
Signature C — raw prose. A memo, a draft, or a transcript discussing "places this text is unclear." No formal scenario structure. The skill must do more work: identify candidate ambiguities, split into discrete scenarios, propose a defect family for each. Confirm the extraction with the user before rendering — the rendered output is only as good as the structure.
In all three cases, the source text (the statute / contract / regulation / opinion being audited) needs to be identified. If the input does not include the full source text, ask the user to provide it. The skill can render scenarios without the source, but the result is much weaker — the source is the spine of the document.
Stage 2 — Build the canonical spec
The spec schema is documented fully in resources/data-format.md. The top-level shape:
Build this iteratively: start with the source text and the scenarios (the two most important), then add the optional sections (families, coverage list, methodology) if the input supplied them or if the user wants them. The families block is auto-derivable from the family keys used in scenarios; supply a default label table and let the user override descriptions.
Anchor IDs. Every scenario links to one or more provisions of the source. Anchor IDs must match the IDs assigned to provisions in source.sections. Use a consistent scheme — for statutes, ID by subdivision marker (a, b1, b2, b6B, c); for contracts, by clause number (s2_1, s2_1_a); for opinions, by paragraph or holding-fragment (p3, holding_1).
Save the spec to <output-dir>/spec.json before rendering. This makes the rendering deterministic and re-runnable when the user wants design tweaks without rebuilding the analysis.
Stage 3 — Choose the format and design
Capability check — do this first
Establish what the host can do before offering anything. Three questions, answered once:
- Can it run Python 3 and write files? The two website renderers and the LaTeX renderer are bundled scripts; without script execution and a writable directory, none of them can run.
- Are the `docx` and `pptx` skills available? Those two formats delegate to them.
- Is a LaTeX distribution installed? Only relevant if the user wants a compiled PDF rather than the
.texsource.
Do not guess. Where a capability is uncertain, the cheapest test is to attempt the smallest version of it and see. Then offer the user only the formats that will actually complete, and say briefly why any others are unavailable — "no Python here, so the multi-page site is out; single-file HTML gives you the same content in one page" is a better experience than a failure five minutes in.
If nothing but plain text is possible, say so plainly rather than half-rendering. A user told at the outset can go elsewhere; a user told at the end has lost the work.
The six options
| Format | Requires | When to use | |
|---|---|---|---|
| Multi-page website (default where available) | Python 3 + filesystem | Citeable per-scenario URLs; reference site readers will come back to; deployable to Netlify or any static host. | |
| Single-page interactive website | Python 3 + filesystem | Dashboard view of everything at once; cross-linking by click; good for an in-house tool or an exhibit. | |
| Single-file HTML | Nothing | One self-contained .html file, written directly without the scripts. The universal fallback, and the right answer whenever the deliverable needs to be emailed or opened by someone who will not unzip a folder. See resources/format-inline-html.md. | |
| Microsoft Word document | docx skill | A litigator or legislator who will read in Word; reviewable with tracked changes; printable. | |
| PowerPoint deck | pptx skill | A meeting, a CLE, a pitch — one scenario per slide, family color on the band, speaker notes carrying the analysis. | |
| LaTeX source | Python 3 + filesystem | A typeset deliverable for an academic audience; footnotes for analysis; submission-quality typography. Produces .tex; compiling it to PDF needs a LaTeX distribution on the user's machine. Do not promise a PDF before confirming one is installed. |
Design tokens. Five values cover 95% of customization needs: accent_color (the primary brand color — red-orange burnt-sienna by default), accent_soft (a lighter complement, auto-derived if not supplied), dept_color (Position A side panel — slate blue by default), adv_color (Position B side panel — usually mirrors accent), and background_color (warm cream by default). Fonts default to Fraunces / Inter / Crimson Pro on the web, system serifs in Word, and Latin Modern in LaTeX. Family color palette is fixed but can be overridden via design.family_palette.
If the user specifies a brand context — "for a corporate audit," "in our firm's colors," "for a state legislator" — match the palette to that. A corporate audit reads cleaner with navy + slate; legislative work reads better with the warmer default; academic work can lean to monochrome.
Stage 4 — Render
Each format has its own reference file with detailed instructions. Read the relevant one before rendering. The rough invocations:
Website (multi or single page) — bundled script:
The script emits a complete static site (HTML + CSS) ready to upload to Netlify. See resources/format-website.md.
Single-file HTML — no script. Write one self-contained .html file directly from the spec, inlining the stylesheet and every scenario. This is the fallback when Python is unavailable, and a legitimate first choice whenever the deliverable has to survive being emailed. Full instructions in resources/format-inline-html.md.
Word document — delegate to the docx skill. Read resources/format-docx.md for the document structure (title page, executive summary, statute-as-block, scenarios as level-2 sections, redrafts appendix, methodology appendix). Build via the docx skill's python-docx pattern.
PowerPoint deck — delegate to the pptx skill. Read resources/format-pptx.md for the slide structure (title, statute overview, one slide per scenario with family-color band, redrafts slide, methodology slide). Speaker notes carry the analysis. Build via the pptx skill's tooling.
LaTeX — bundled script:
The script emits a self-contained .tex file using the article class with a clean preamble. The deliverable is the `.tex`. Compiling it to PDF requires a LaTeX distribution — latexmk -pdf report.tex, or pdflatex run twice. Attempt the compile only where a distribution is present; where it is not, hand over the .tex and say plainly that it needs LaTeX to typeset, rather than reporting a failed PDF. See resources/format-latex.md.
All formats at once. If the user asks for all formats from one invocation, run the renderers in sequence and present each output. This is useful when a deliverable is going to a mixed audience (the litigator wants the Word doc, the colleague wants the link to the site, the meeting wants the deck).
Output organization
Default output directory: <source-name>-ambiguity/ in the workspace folder if one is connected, otherwise in the temporary outputs folder. Within it:
This is the start of the file. Read the full SKILL.md on GitHub.
Security
- Security scanPassed, 100 of 100Pattern checks on the skill's files.
- Model reviewNot runA model review is scheduled for the next rescan.
Quality evaluation
- Task evaluationNot runNo evaluation yet. Run one in Skill Studio.
Source
- SKILL.md in the repositoryCheckingskills/ambiguity-report-seth-chandler/SKILL.md
Popularity
- Repository stars
- 689
- Repository forks
- 88
- 7-day trend score
- 33
Stars and forks are for the whole GitHub repository, not this skill alone. Refreshed 10 Oct 2026, a month ago.
Works with
Any agent vskill installs to: 56 targets in all. These 39 have a page on this site.
- Claude Code
- Cursor
- GitHub Copilot
- Windsurf
- Codex
- Gemini CLI
- Cline
- Amp
- Roo Code
- Goose
- Continue
- Kilo Code
- Junie
- Trae
- OpenHands
- Qwen Code
- AI Agent
- Tabnine Chat
- Sourcegraph Cody
- Amazon Q
- Firebase Genkit
- Sweep
- Devin
- Phind
- Mentat
- Claude Desktop
- Aider
- GPT Pilot
- Plandex
- bolt.new
- v0
- Replit Agent
- Anse
- TypingMind
- BetterChatGPT
- LibreChat
- Warp AI
- Pieces
- Fig AI
Embed badge
[](https://verified-skill.com/skills/lawve-ai/awesome-legal-skills/ambiguity-report-seth-chandler)