How do I install the Pocdd Work skill?

Run npx skillmds@latest add dailybothq/pocdd-work in your terminal (requires Node.js), paste this page's agent-chat prompt into Claude, Cursor, or any MCP-connected agent, or download the SKILL.md file and copy it into your agent's skills directory.

Is Pocdd Work safe to use?

This skill has not completed SkillMD's automated safety review yet. SkillMD never runs a skill's scripts for you; review the SKILL.md before installing.

Which AI agents work with Pocdd Work?

This skill is tagged as working with Claude Code, Claude.ai, OpenAI Codex. SKILL.md is an open format, so most agents that read a skills directory can load it too.

Is Pocdd Work free to use?

Yes. Installing skills from SkillMD is free, and the skill stays under its author's original license.

Who published Pocdd Work?

dailybothq (@dailybothq) published this skill. Their other Agent Skills are listed on their SkillMD profile.

Pocdd Work by dailybothq — Agent Skill

Name: Pocdd Work
Author: dailybothq

Pocdd Work

Run the POCDD gap-closing loop on an existing POC file — close [agent] investigation gaps autonomously (at most gaps_per_pass per invocation), defer [user] decision gaps with a recorded assumption, and advance the file toward ready-to-implement without ever stopping execution. Use for "/poc work <name>" or "close the gaps".

dailybothq 2641995 2.6 KB Updated Sep 17, 2026

File contents

POCDD — Work (the gap-closing engine)

This is the heart of POCDD. Read ../shared/conventions.md first. Resolve the target with pocdd_resolve <name> from ../shared/context.sh.

Budget: close at most 2 [agent] gap(s) per /poc work invocation (profile mid). Then stop, summarize, and invite another pass.

The loop

Load the POC fully — Goal, Implementation, Remaining gaps, phase. Set phase: shaping.
Work up to 2 [agent] gap(s) in id order:
- Do the investigation: run the script (for runnable POCs, with the relevant flags), read the referenced code paths, or diff output against expectations.
- Capture the result as a Finding in Implementation, tagged with provenance ([ran it], [code: path:line], …).
- Remove the gap from Remaining gaps. Add any newly discovered gaps.
- If you hit the per-pass budget, stop closing further [agent] gaps.
Defer every [user] gap — never stop. For each decision gap you encounter:
- Record a default assumption to proceed with.
- Link the dependent Implementation (e.g. "§4 assumes G3 = hourly").
- Leave the gap in Remaining gaps (owner [user]); keep going.
Re-derive the phase:
- any gaps left → stays shaping.
- none left → ready-to-implement.
- a gap proved the goal infeasible/too costly → not-viable (record the killer finding).
Surface decisions in a batch. At the end of the pass, present the open [user] gaps (with the assumption you ran with for each) and any remaining [agent] gaps still open after the budget. Resolving a gap may close it or spawn new gaps — re-run /poc work afterward.

Rules

Execution never blocks on a human. Decisions become deferred gaps, not stop points.
Move proven knowledge into Implementation with provenance — don't leave findings buried in chat.
Keep directives verifiable: every "what to do" gets a done-check.
Reference codebase by path; never copy production code into the file.
Report progress as a short summary: gaps closed this pass, findings added, decisions awaiting the developer, remaining [agent] gaps, new phase.

---name: pocdd-workdescription: Run the POCDD gap-closing loop on an existing POC file — close [agent] investigation gaps autonomously (at most gaps_per_pass per invocation), defer [user] decision gaps with a recorded assumption, and advance the file toward ready-to-implement without ever stopping execution. Use for "/poc work <name>" or "close the gaps".---# POCDD — Work (the gap-closing engine)This is the heart of POCDD. Read [`../shared/conventions.md`](../shared/conventions.md)first. Resolve the target with `pocdd_resolve <name>` from[`../shared/context.sh`](../shared/context.sh).**Budget:** close at most **2** `[agent]` gap(s) per `/poc work`invocation (profile `mid`). Then stop, summarize, and invite another pass.## The loop1. **Load the POC fully** — Goal, Implementation, Remaining gaps, `phase`. Set `phase: shaping`.2. **Work up to 2 `[agent]` gap(s)** in id order: - Do the investigation: run the script (for runnable POCs, with the relevant flags), read the referenced code paths, or diff output against expectations. - Capture the result as a **Finding** in **Implementation**, tagged with provenance (`[ran it]`, `[code: path:line]`, …). - Remove the gap from **Remaining gaps**. Add any **newly discovered** gaps. - If you hit the per-pass budget, **stop closing** further `[agent]` gaps.3. **Defer every `[user]` gap — never stop.** For each decision gap you encounter: - Record a **default assumption** to proceed with. - **Link** the dependent Implementation (e.g. *"§4 assumes G3 = hourly"*). - Leave the gap in **Remaining gaps** (owner `[user]`); keep going.4. **Re-derive the phase:** - any gaps left → stays `shaping`. - none left → `ready-to-implement`. - a gap proved the goal infeasible/too costly → `not-viable` (record the killer finding).5. **Surface decisions in a batch.** At the end of the pass, present the open `[user]` gaps (with the assumption you ran with for each) and any remaining `[agent]` gaps still open after the budget. Resolving a gap may close it or spawn new gaps — re-run `/poc work` afterward.## Rules- **Execution never blocks on a human.** Decisions become deferred gaps, not stop points.- Move proven knowledge *into Implementation* with provenance — don't leave findings buried in chat.- Keep directives verifiable: every "what to do" gets a done-check.- Reference codebase by path; never copy production code into the file.- Report progress as a short summary: gaps closed this pass, findings added, decisions awaiting the developer, remaining `[agent]` gaps, new phase.

Frequently asked questions