@dzhng: Fed this article to Fable and we created an explore-unknowns skill It scans your codebase, then interviews you one ques…
Summary
A personal library of composable AI skills for building software factories, including an explore-unknowns skill that scans codebases and interviews developers to close known and unknown unknowns.
View Cached Full Text
Cached at: 07/05/26, 02:32 PM
Fed this article to Fable and we created an explore-unknowns skill It scans your codebase, then interviews you one question at a time to close the known unknowns Then sweeps for the unknown unknowns you never thought of Now part of my software factory: https://github.com/dzhng/skills
dzhng/skills
Source: https://github.com/dzhng/skills
Skills
AI skills for building software factories. My personal library of domain-agnostic agent skills, reused across every project. Small, composable, and hackable — works with any harness that supports skills: Claude Code, Codex, opencode, Cursor, duet, and 70+ others.
npx skills add dzhng/skills
Add --list to pick individual skills, or copy any skills/<category>/<name>/
folder into your harness’s skills directory (e.g. .claude/skills/).
Why
Software is moving from tasks to factories: agents that pursue a goal autonomously until the output can be trusted. The hard part isn’t breaking the goal into tasks — it’s breaking it into independently verifiable pieces, and knowing where the pieces even are.
These skills run that loop. Treat the unknown as fog of war: map the terrain, carve it into territories that build and verify in isolation, and recursively re-slice whatever hides more map. And re-planning doesn’t stop when planning ends — the spec is a living document, updated and re-sliced mid-implementation whenever the work teaches the agent that the plan is stale. Every piece must prove itself — architecture review, code review, and visual review against a baseline — before the loop moves on. Each iteration gets less wrong, until the goal is done.
Proof: one unattended Codex run pursuing a single goal for 1d 16h on top of these skills, slicing and iterating until done.
How to use
-
Plan. Ask your agent to
/write-specthe goal. It interviews you, researches the unknowns, and materializes a spec underspecs/<feature>/— a slice graph where every slice is independently verifiable. -
Build. Kick off the loop:
/goal /implement-spec specs/<feature>Add whatever framing fits:
on the xyz branch, orusing /codex as the implementer while you stay the parent orchestrator and reviewer. -
The rest fires on its own. The spec tells the loop when to call the other skills —
/refactor-cleanand a review pass at the end of every slice,/screenshot-critiqueand/compare-screenshotson anything visual,/close-specwhen the last slice lands — and to update and re-slice the plan whenever implementation proves it stale. Every skill is also independently useful: invoke any of them manually whenever you want.
Skills
Engineering — slice, build, verify, repeat
| Skill | What it does |
|---|---|
| explore-unknowns | Walk the user through mapping a task’s unknowns quadrant by quadrant — known knowns first, then interviews, reactable artifacts, and blindspot passes — ending with a complete four-quadrant map. |
| write-spec | Break a large feature into independently verifiable, human-reviewable slices with API seams and playable checkpoints. |
| implement-spec | Build an existing spec to completion, one reviewable pass at a time, delegating independent slices in parallel. |
| implement-spec-with-codex | Run implement-spec with Codex writing the code — you orchestrate, integrate, and review every pass. |
| close-spec | Archive a shipped spec and rewrite it from a build plan into a durable rationale record that points back at the code. |
| refactor-clean | Refactor by moving ownership to one clean concept instead of layering compatibility sediment beside the problem. |
| write-docs | Write docs as a glossary of principles and pointers, never a mirror of the code that will rot. |
| codex | Use the local Codex CLI as an independent second agent for review and (on explicit ask) delegated implementation. |
| claude | Use Claude Code (claude -p) as an independent second agent for consultation and (on explicit ask) delegated implementation. |
Visual review — never accept visuals on vibes
| Skill | What it does |
|---|---|
| compare-screenshots | Judge which image is less wrong against a target you establish — telemetry to locate divergence, not a baseline match. Ships a reusable diff script. |
| screenshot-critique | Use an unprimed subagent as a second set of eyes on visual work before accepting it. |
| preview-shots | Open a curated set of image shots in one macOS Preview window for the user to eyeball. |
Authoring — keep the skills themselves sharp
| Skill | What it does |
|---|---|
| write-skills | Create or revise agent skills: triggers, leading words, progressive disclosure, and the failure modes to prune. |
| eval-skills | Eval a skill against golden cases — blind runs in fresh subagents, a separate judge, and gap-driven edits. |
Graphics
| Skill | What it does |
|---|---|
| renderer | Build, debug, or review WebGPU renderer work — three.js/TSL scene layers, node materials, WGSL passes, depth semantics, and browser-verified visuals. |
License
MIT
Similar Articles
@dzhng: I got tired of using the same prompt to ask fable to use codex as implementor that I added a new implement-with-codex s…
Dzhng released a personal library of composable AI agent skills for autonomous software development, including a new 'implement-spec-with-codex' skill that uses Codex as the implementor.
@trq212: I’ve found the most important part of working with Fable is discovering my own unknowns so I can prompt it better, here…
A user shares their approach to improving prompts when working with Fable, an AI tool, by identifying their own knowledge gaps.
@bozhou_ai: https://x.com/bozhou_ai/status/2074030629956780417
Based on Anthropic employee Thariq's article "A Field Guide to Fable", the author rethinks the management of unknowns in AI programming workflows. It proposes methods such as blind spot scanning, multi-version prototyping, AI interviews, implementation notes, and quizzes, emphasizing the importance of discovering unknown factors before coding to reduce rework.
@gyro_ai: https://x.com/gyro_ai/status/2055198700016660826
Matt Pocock open-sourced Skills for Real Engineers, a set of small, composable, and hackable AI coding skills designed to address issues in AI programming such as understanding bias, lack of shared language, missing feedback loops, and software entropy. The tool enhances AI programming efficiency through skills like grill-with-docs, tdd, and diagnose, and provides a complete workflow.
@dzhng: Hot tip: use Fable-5 for planning and as the general orchestrator and reviewer, and Codex as the actual implementer so …
Tip to use Fable-5 as orchestrator and Codex as implementer to save credits, with a link to a library of composable AI agent skills for autonomous software development.