syafiqkit

This skill should be used when the user asks to "setup project agents", "create code reviewer", "update agent prompts", or when starting a new project — AND whenever a project's `.claude/agents/*.md` files are missing, have fallen behind what `templates/*.template.md` can now do — a step, a tool grant, a guard or a whole subject the template covers and the agent has no counterpart for, which is different from the two files merely wording the same rule differently — or the user reports an agent misfiring/under-triggering (wrong dispatch behavior traces back to a stale or absent agent file, not the calling skill). Also trigger when a NEW agent template is added upstream and an existing project's agents need to pick it up. Creates project-specific agents with the Bootstrap pattern. Do NOT use for a one-off tweak to a single agent's wording (edit that agent file directly) or for fixing a SKILL.md's own trigger description (that's update-plugin).

Use this before creative work that involves design decisions - new features with multiple approaches, or architectural changes. Explores intent and requirements before implementation. Triggers on brainstorming, design exploration, "how should we build", or when multiple valid approaches exist. For UI/UX specifically, `uiux` owns design judgement on a surface whose purpose is already settled (polish, rethink, redesign) — this skill runs first only when what to build is itself open, since its hard gate blocks all implementation until the user approves a direction.

Write a message in the sender's own voice to a specific person or small group — a WhatsApp reply, a Google Chat DM to a colleague, texting someone back, telling a named person something. Casual by default: short, no fence, no section headers, closes the way the sender actually talks. Fires on "reply to X", "tell Y that...", "make it sound like me", "my usual WhatsApp message", "just a quick text", "reply casually", or naming a recipient by name or relationship rather than by audience category. NOT for a document being posted or converted — a changelog, release note, status update, or already-drafted prose someone wants reformatted for Chat's markdown is `gchat-format`, even when the destination is a 1:1 DM.

Diagnose and fix CI/CD deploys that intermittently fail when the runner can't SSH into the target server — errors like `dial tcp ***:22: i/o timeout`, `ssh: connect to host ... port 22: Connection timed out`, `Connection refused`, or a deploy step that "usually passes on the 2nd or 3rd re-run." Use this WHENEVER a GitHub Actions / GitLab CI / generic SSH deploy step times out reaching a server, ESPECIALLY before adding a firewall rule or IP allowlist — those are usually the wrong fix. The skill rules out firewall / fail2ban / sshd throttling systematically, then converts the deploy to a connect-retry pattern that self-heals transient drops without re-running genuine failures. Triggers on "deploy keeps timing out", "ssh i/o timeout in CI", "runner can't connect to my server", "flaky deploy", "should I allowlist the runner IPs", "deploy fails intermittently then works on retry".

Create git commits from staged changes. Works for single repos and multi-repo projects. Use when the user says "commit", "commit this", "commit staged changes", or asks to create a commit message from what's staged.

Generate invoice line items from git commit history. Analyzes commits to create billable service descriptions with estimated hours. Use when creating invoices, billing for development work, analyzing commit patterns for time tracking, or when user mentions "invoice", "billable hours", or "time log".

Aggressively condense and restructure a bloated CLAUDE.md file — strip verbose WHY columns, discoverable content, redundant tables, and overly long rows, then rewrite it shorter and clearer. Use when the user says "condense", "shrink", "trim", "clean up", or "make CLAUDE.md shorter", or when the file exceeds ~200 lines OR ~40KB — check both, since a dense file can hold its line count while bytes climb well past budget. Also use when asked to "restructure" or "rephrase" CLAUDE.md sections. Do NOT confuse with claude-md-improver (which adds missing content) — this skill removes excess.

Produce a copy-paste prompt that starts a fresh session where this one stopped — the task doc path, the one next task, the blocker, and uncommitted state. Use when the user says "continuation prompt", "handoff prompt", "carry this over", "I'm running out of context", "start a new session for this", "what do I paste into the next one", or when a session is ending with work deferred rather than finished. Offered by `done` and `quick-done` at wrap-up. This WRITES A PROMPT and stops — it does not continue the work. "Let's continue" / "do the next steps", meaning carry on building now in this session, is `tackle`. Briefing a person or an external designer is `design-handoff`.

Write a brief for someone ELSE to design a screen — an external designer, a Claude Design project, a contractor, a teammate who cannot read this repo. Fires on "give me the prompt", "brief for the designer", "I'll prompt over there", "hand it to Claude Design", "business side only", "what do they need to know". Also fires when a reply is about to volunteer a layout, component list or step breakdown for work someone else owns. NOT for designing it yourself — that is `uiux`, which applies design judgement here; this skill deliberately withholds it and ships context instead.

Post-task cleanup - simplify code, review changes, update docs, capture session knowledge. Use when finished implementing or when user says "done", "wrap up", "finalize".

Turn a task doc, backlog or worklist into a black-and-white Excalidraw discussion board the team can read cold and doodle on later — columns for now / gated on our own build / waiting on someone else, thick-bordered GATE cards with arrows to what they unblock, a PARKED table with a revive trigger per row, and a right-hand strip for decisions, open questions and actions filled in live. Use when the user says "excalidraw", "whiteboard", "let's draw the plan", "board for the meeting", "something to discuss with KL/HL", "what's on hand, what's deferred", or asks how best to lay out tasks for a discussion. Not for charts or dashboards (that is `dataviz`), not for architecture or sequence diagrams (draw those directly with the Excalidraw MCP), and not for deciding what to build (that is `plan-worklist`; this skill draws a worklist that already exists).

Pull a module that two or more apps need out of the app that has it and ship it as a shared package — Composer or npm, any vendor, any framework — consumed by every app, with the boundary, hosting, versioning, CI and rollout decided in the right order. Use when the user says "extract this into a package", "make this reusable by both apps", "shared package", "build it once for both", "monorepo or separate repo for the shared package?", "private composer/npm package", "publish this as a library", "add a capability to our shared package", or asks how another project should consume code that lives in this one. Not for scaffolding a brand-new library with no existing consumer (write it in the app first), not for a fact that belongs in CLAUDE.md (that is `update-claude-docs`), not for cutting an app's own release (that is `ship`), not for an open design question with no module to extract yet (that is `brainstorming`); the research legs inside this skill go to `haiku`.

Apply and enforce the function/method parameter-count best practice — 0 params is ideal, 1-2 is fine, 3 is the signal to stop and wrap arguments into an object/DTO, and 4+ almost always means the function is doing too much. Use this WHENEVER you are writing or reviewing a function with a growing argument list, when someone asks "how many parameters is too many", "should I wrap these into an object", "is this signature too long", or "add a lint rule for parameter count", and ESPECIALLY before adding a 4th positional argument (or a 2nd boolean/same-typed one) to any function. Also use it to set up an enforceable linter rule — ESLint `max-params` for TS/JS, PHPMD `ExcessiveParameterList` for PHP, Pylint for Python — with the right limit and the right carve-outs. Triggers on "too many parameters", "long parameter list", "parameter object", "introduce a DTO", "max-params", "this function takes too many args", "wrap these arguments", "lint rule for function arguments".

Convert Markdown or plain text into Google Chat-compatible formatting. Use this skill whenever the user wants to send a message in Google Chat, format a changelog/release note for Google Chat, convert a Markdown document for posting in Google Chat, or says anything like "format this for Google Chat", "convert to Google Chat", "post this in Chat", "gchat format", or "make this Chat-friendly". Google Chat has a limited, non-standard subset of Markdown -- this skill ensures correct output every time. NOT for composing a message in the sender's own voice to a named person or small group -- a WhatsApp reply, a quick DM, "tell X that..." -- even when the destination is Google Chat: that's `casual-message`.

Run a task, or a named skill, on one or more haiku agents instead of the current session — then verify the result before reporting it. Use for research, bulk reading and survey work, and for mechanical rewrite passes (`condense-claude-md`, `condense-task-doc`, `unhobble-instructions`) where haiku is fast and good at restructuring. Trigger on "haiku this", "run X on haiku", "get haiku to research Y", "use haiku for the condense", "spin up N haikus for Z", "delegate this to haiku", or any request naming haiku as the thing that should do the work. Also fires when the user asks for several agents in parallel on disjoint work and doesn't name a tier. Not for choosing WHICH skill to run — name the skill and this dispatches it; deciding what needs doing is the calling session's job.

Something came up mid-task that is arguably not yours to decide — a defect found while building something else, a fix that would refuse what currently succeeds, a scope question, a workaround whose cost lands on someone else. Use when about to escalate ("should I fold this in", "is this in scope", "do you want me to also fix", "worth doing now or later", "I found something while doing X"), and equally when about to stay silent about a real finding. Decides whether the call is yours or the user's, and makes the question answerable before asking it. Not for shaping a question you have already decided to ask (that's `_shared/references/decision-first-output.md`), not for choosing between design approaches on work already agreed (that's `brainstorming`), not for scoping a list that already exists (that's `plan-worklist`).

Convert Markdown documents to professional PDFs with rendered Mermaid diagrams and charts (bar/line trend charts via xychart-beta). Use when user asks to "export to PDF", "generate PDF", "make a PDF", needs a shareable document from markdown files, or asks for a "chart"/"graph"/"diagram" in a report or document.

Find related task docs that should be merged together, merge them into a single coherent document, delete the sources, and reconcile all back-references to the deleted paths. Use this whenever the user says "merge these docs", "find payment docs and merge", "consolidate task docs", "combine related docs", "find all X docs and merge", "these docs overlap, merge them", or asks to clean up / reduce the number of task docs in a domain. Also use it proactively when a task-summary update reveals that a doc's content already lives in another doc — don't just update both, propose a merge.

A pre-scoped list of work items already exists — findings from a read-summary/investigation pass, a pasted backlog or ClickUp list, a brainstormed todo list — and the user wants it turned into a build plan before anyone writes code. Dispatch product-reviewer to judge each item against the product's intent (task doc) and size/sequence them, then present the plan and stop. Triggers on "let's do these", "use product reviewer to see it first", "scope this list", "plan these out", "which of these should we build first", said against an existing list — not a single vague idea. Do NOT use for a vague "let's continue" against one doc with no list in hand (that's `tackle`), for exploring a single new feature with multiple design approaches (that's `brainstorming`), or for reviewing code that was just built (that's `done`, which dispatches product-reviewer post-build instead of pre-build).

Pull a remote server's database to the local development environment. Handles mysqldump on server, binary-safe transfer via scp, MariaDB→MySQL compatibility fixes, password reset, and cleanup. Use when the user says "pull db", "copy production database", "sync db from server", "get real data", "import prod db", "pull database locally", or wants to test with production/staging data.

The cheap post-task wrap-up for a session you already know was small — the CLAUDE.md capture pass and one task-doc update, nothing else. Use when the user says "quick done", "quick wrap", "small change, just quick-done it", "wrap it up cheaply", or otherwise pairs a wrap-up request with a size or cost signal ("small", "quick", "cheap", "light", "just a typo") — that pairing beats /done's bare "wrap up" trigger. This skill is docs-only and spawns no reviewer, so nothing here reads the code for defects; it deliberately skips the code review, the simplifier, and the product reviewer. Use /done instead for anything multi-file, multi-domain, a new user-facing flow, anything about to ship, or when it isn't clear which fits — /done is the safe default, this skill is the deliberate exception.

Read task summary context and project instructions before answering investigative questions, implementing work, or starting a new domain within a session. When a request about current system behavior, a deploy question, a bug report, or an unfamiliar domain is asked, this skill finds and reads the right docs first — decisions and gotchas live there, not in the code alone, so skipping them is how confident-but-wrong answers happen.

Establish a project's core documentation set — PRD, ARCHITECTURE.md, ARCHITECTURE-ESSENTIALS.md and the CLAUDE.md/AGENTS.md entry points — either for a greenfield project being scoped or for an EXISTING codebase adopting docs for the first time. Use when the user says "set up the docs", "we need a PRD", "scaffold the project docs", "adopt this repo", "there's no documentation here", "write an architecture doc", "onboard this codebase", "document what this thing actually does", or names the five-file doc structure. Also fires when work is about to start on a repo whose constraints live only in people's heads or in scattered meeting notes. Do NOT use for capturing one gotcha or pattern into an existing CLAUDE.md (that's `update-claude-docs`), for a feature's task doc under `tasks/` (that's `task-summary`), for an end-user guide (`user-manual`), or for shrinking docs that already exist (`condense-claude-md` / `condense-task-doc`).

Ship code to production — commit, changelog, push, verify CI/CD deploy, generate release note. Use when the user says "ship", "ship it", "deploy", "push to prod", "send it", or after /done is complete and code is ready to go live. Works with single repos and multi-repo setups (root + sub-repos). Assumes /done (or /quick-done for a small session) was already run.

Create a new skill — draft its SKILL.md, place it in the right location, register it in the skill tables, and pressure-test that its trigger actually fires. Use when the user says "create a skill", "make a skill for X", "turn this into a skill", "I keep doing X manually", or describes a workflow they want captured for reuse. Also use when a session reveals a repeated procedure worth capturing that no existing skill covers. Do NOT use for editing an existing skill's trigger or workflow (that's `update-plugin`), for auditing one for overconstraint (`unhobble-instructions`), or for creating an agent (`agent-setup`).

Fleet-wide scan across ALL tasks/ domains to surface CROSS-domain doc merge candidates that a single-domain `merge-task-docs` invocation would never see (e.g. `payment/stuck-payment` overlapping `payment/gateway`, or a stray doc that belongs under a different domain entirely). Use when the user says "check for similar docs across domains", "find overlapping docs across the whole project", "sweep all task docs for merges", "is anything duplicated across domains", or asks a merge question without naming a specific domain/keyword. Hands the resulting candidate list to `merge-task-docs` for execution — this skill does discovery only, never writes/deletes docs itself.

Vague multi-item doc continuation ("let's continue", "do the next steps") — read the doc via read-summary, then use judgment on what's actually buildable before starting; don't just ask which items they want. A specific ask, even against a doc, is read-summary's job, not this. Asking for a prompt to carry the work into a FRESH session — "continuation prompt", "I'm running out of context" — is `continue-session`; this skill continues the work here and now.

Create, update, or rewrite task summary documentation (current.md and its decisions/*.md theme files). Handles path resolution, domain inference, template selection, cross-references, Quick Start writing, and splitting an oversized theme file into sub-files. This is `/done` Step 4 — after implementation work, invoke `/done` rather than this skill alone, so the sibling steps (review, CLAUDE.md capture) run too. Use directly for ANY task documentation workflow — including "rewrite with proper template", "conform to template", "add a Quick Start", or continuing/finishing doc work from an earlier turn in the same session — even if the template shape is already known from a prior read. Invoke this skill fresh each time rather than editing docs directly against a recalled structure; its rules (condense/split thresholds, validation greps) can move between sessions.

Apply design judgement to UI/UX work at any scope — polish, rethink, redesign, or tighten. Fire on explicit requests (redesign, rethink, polish, "make this nicer") and implicit ones: a screenshot arrives, or someone reports what they saw ("looks wrong", "shows the old one") without naming UI. Also fires on greenfield projects (no app language yet), judges whether existing design languages are dated, and treats mobile-first as the default. Will NOT fire on backend-only work or chart building (that is dataviz), nor when the ask is a BRIEF for someone else to design (an external designer, a contractor, a Claude Design project) — that is `design-handoff`, which ships context and withholds the design decisions this skill makes. When exploring what to build comes before how it should look, `brainstorming` runs first.

Create, rewrite, condense, or capture-into CLAUDE.md files following best-practice structure. Use after implementing features or fixing bugs to capture reusable patterns/gotchas (the /done Step 3 default), OR when the user wants to scaffold a new CLAUDE.md for a repo/subdir, restructure an existing one to the canonical section layout, or shrink a bloated file. The CLAUDE.md analog of task-summary. Triggers on "update claude docs", "capture this into CLAUDE.md", "create/write a CLAUDE.md", "rewrite/restructure CLAUDE.md", "make CLAUDE.md follow best practice", "add this gotcha to the docs".

Scan the session for learnings about the syafiqkit plugin itself, then patch the affected skill files — trigger descriptions, workflow steps, gotcha and rule tables. Use it when a skill misfired (triggered wrongly, stayed silent when it should have fired, a step turned out wrong mid-execution, or you worked around its instructions), when a session hand-edited a skill/command/agent file even with no defect, and as a near-session-end sweep. Cue phrases: "update the plugin", "capture this for the skill", "improve the skill based on this session", "fix the skill trigger". It patches skills that already exist — creating a new one is `skill-creator`, a project gotcha or a general communication preference is `update-claude-docs`.

Update task summaries with session findings. Alias for task-summary — creates if missing.

Write or extend an END-USER manual — a guide for the people who use the product, not the people who build it. Fires on "write a user manual", "buat guide", "we need a guide for the dealers/customers/staff", "document how to use X", "make a manual for the new module", and on requests for a shareable Word or PDF edition of one. Also fires when someone reports an existing guide is wrong in shape: "this reads like a reference not a manual", "there are no steps", "it's just a QnA", "where are the screenshots". Covers scoping against what users actually do, capturing screenshots from the E2E suite rather than by hand, and building .docx/.pdf editions. NOT for internal engineering docs (that is task-summary), NOT for CLAUDE.md instruction files (update-claude-docs), and NOT for plain format conversion of a document whose content is already settled (md-to-pdf).

Create task summary documentation. Alias for task-summary — use when starting new feature work.