Takes a piece of work from request to an open PR with proof. It asks everything up front - what the user wants, and for each goal where it is seen, what right looks like and what counts as a pass - prototypes screens and logic first, plays the whole plan back for one confirmation, locks the answer keys, then builds, tests, proves, reviews and opens the PR, with no questions between the playback and the final ship checks unless something blocks it. Works with any coding agent. Use when the user says deliver this, build this end to end, take this from idea to PR, do the whole thing, "ask me everything first, then go", or hands over a feature, screen, flow, endpoint or change they want built and proved. Not for a quick question or a one-line fix - use coding; not for only discussing or writing a design doc - use design-docs; not for checking a change that already exists - use prove.
Avik-creator/agent-skills
Skills for coding agents: code, test, debug, review, refactor and ship, with the rules each stage needs.
Repository statistics
Indexed skills
19
Skill groups
1
GitHub stars
0
Forks
0
Skills
19 totalProves a change works in the real running app before anyone says done - it starts the app, drives every flow the change touches the way a user or program would, compares the result with an answer key the builder did not write, and gets the verdict from a fresh agent, with evidence saved locally. On first use in a repo it sets up that repo's verifier (how to launch, check, drive and clean up the app, plus a feature map), and on branches the deliver skill marked, a global git pre-push hook blocks any push that was not proved. Works with any coding agent. Use when the user says prove it, verify this works, check it in the real app, show me it works, set up verification for this repo, "the agent keeps saying done without testing", when a push is blocked by "prove:", or before handing over or pushing any change. Not for writing test files - use testing; not for reviewing a diff - use `review`; not for a one-off browser task - use automation.
Takes a finished change to an open pull or merge request, then stops so the user merges and releases. Runs self-review and a done gate, scans the diff for a lowered bar (new suppressions, skipped or deleted tests, removed assertions, stubs), commits in logical pieces, then interviews the user about the feature and checks each answer against the code before anything is pushed; on branches the deliver skill marked, a global git pre-push hook blocks any push without the interview and a prove receipt. Use when the user says ship it, ready to ship, wrap this up, we're done, push this, open a PR or MR, create a merge request, or asks for a rollback plan, a deploy or release checklist, a version bump, a tag or a changelog, or to clean up after a merge. Not for reviewing someone else's PR - use `review`; not for adding telemetry or alerts - use observability.
Drives a real browser or desktop app to test, check or automate anything that needs a real interface - opening pages, clicking through flows, filling forms, taking screenshots, confirming a feature works. Also checks the agent's own work in the real interface after a change, when the user asks it to or the testing skill needs it. Uses browser-use (the user's own Chrome) first, then agent-browser (a separate, clean Chrome), then agent-desktop for desktop apps only after asking. Use when the user asks to automate a web or desktop task, test or check something in the browser, verify or check your own work, click through a flow, reproduce a UI bug, take a screenshot of a page, or fill a form. Not for writing test files that run again (use testing), proving a change against an answer key before a push (use prove), or fetching a public page or API that a plain request can read.
Reviews a code change through a fresh subagent that proves each finding - a failing test, a reproduction or a mutation the tests miss for a bug, the quoted rule for a rule breach - and reports proven findings apart from unproven risks and opinions. Checks the change against what it was meant to do (decisions agreed with the user, a design write-up, the PR or issue) and against the repo's own rules. Runs on its own before handing over any change that affects behaviour, and on request for a branch, commit range, pull request or pasted diff. Use when finishing a code, SQL, migration or config change, or when the user asks to review, check or audit a diff, branch or PR, says "review since X", "look over this PR", "what could this break" or "is this ready to merge", or asks for a strict, deep, harsh or thermo-nuclear code quality review. Not for checking a change in the real app - use prove; not for writing tests - use testing; not for a repo-wide cleanup - use refactor.
Writes automated tests that hunt for errors - edge cases above all, plus logic, structure, state, error-handling and permission errors - and proves each test by making it fail. After feature code it writes the tests and breaks the guarded code to see each one go red; for a bug it writes the reproduction test first and watches it fail before the fix. Covers choosing unit, integration or end-to-end, test doubles, test data, browser tests and flaky tests. Use when writing or fixing tests, adding coverage for a change, after implementing a feature, when fixing a bug, when a test is flaky or a UI test broke, or when the user asks "what could break here" or to check edge cases. Not for listing manual test cases - use test-cases; not for proving a change in the real app against an answer key - use prove; not for reviewing a diff - use `review`; not for finding why something fails - use debug; Go specifics live in the go skill.
Builds a throwaway prototype that answers one design question before real code is written - either a single double-click HTML file that lets anyone drive a state model through guided scenarios, or several structurally different UI variants on a real page, switchable with ?variant=. Keeps everything in a local .prototype/ folder, out of git, and turns the scenarios into the first tests when the answer moves into real code. Use when the user wants to sanity-check a state machine, business rule, workflow or data shape, asks "does this model handle X then Y", wants to click through a flow, wants to see a few layout options for a page or dashboard, or says "prototype this", "mock it up" or "let me try it first"; also when a design discussion stalls on a question talking can't settle. Not for production code or final visual design (use ui-ux-pro-max), or for writing the design document itself (use design-docs).
Picks the skill, or the short chain of skills, for a request that could match more than one or that needs several in order: a bug to diagnose and fix, a feature from spec to merge request, a release, a cleanup, a design. Use when it isn't clear which skill owns a request, or a request spans diagnosis, code, tests, review and shipping. Not needed when one skill plainly fits - load that one directly.
Talks a piece of software work through with the user first - one decision at a time, each with a recommended answer - and only then writes the document together, in plain English anyone can follow. Covers exploring a loose idea into one direction, PRDs, engineering specs, system designs and architecture or scale reviews, information architecture (site maps, navigation, user flows), and documentation such as flows, API references, runbooks, guides and READMEs, with flows drawn on a tldraw canvas or written as Markdown. Use when the user wants to ideate, refine an idea or weigh options, plan or design a feature, asks for a PRD, spec, RFC, design doc, system design, architecture or performance review, site map, navigation or IA, a user flow or flowchart, a runbook, API docs or a README, or says "grill me", "challenge my plan" or "poke holes in this". Not for writing or changing code, visual UI design (use ui-ux-pro-max), or general tldraw canvas edits (use tldraw-offline).
Writes and refines agent skills (a SKILL.md plus optional reference files and scripts) in one standard shape - a trigger-first description, a body under 100 lines, detail split one level deep, and a quick with/without test. Use when the user wants to create a skill, turn a workflow, habit or repeated correction into a skill, edit or tighten an existing SKILL.md, or fix a skill that does not trigger. Not for running formal benchmarks or description-optimization loops - use skill-creator.
Use when writing or changing code, including a test that was asked for. Not for docs, a review, or a design.
Designs, writes, reviews and changes database-backed application code safely - tenant-scoped, index-aware queries, keyset pagination, schema and constraint design, zero-downtime migrations, race-free transactions, connection pooling, and careful access to real databases - with detailed Postgres guidance. Use when writing or reviewing SQL or a data-access layer (query builders, generated queries, drivers, ORMs), adding a table, column, index or migration, building a list or search endpoint, chasing a slow query or connection exhaustion, sizing a pool, or running anything against a dev, staging, preview or production database, even when the user never names the database. Not for warehouse or ELT pipelines (dbt, Spark, Airflow) or server administration such as replication, backups and major-version upgrades.
Use when asked to diagnose, debug, or find why something fails: a crash, a wrong result, an error in a log or CI run, a test that started failing, a failure that comes and goes, a regression, or an error in production. Finds the cause and proves it with evidence, and reads production without changing it. Not for writing the fix or the test - use coding and testing; not for fixing a flaky test - use testing.
Writes, changes and reviews Go code to current standards - version-correct idioms from the Modern Go Guidelines CLI, stdlib-first boring design, and a fixed set of checks before handover - plus verified references for the traps models still miss (typed nil, slice aliasing, context and goroutine lifetimes, json v1 vs v2), stdlib security (os.Root, crypto/rand, CSRF, server timeouts), testing and benchmarks (table tests, b.Loop, synctest), modules, and dated toolchain changes. Use when writing, editing, fixing, refactoring, testing, benchmarking or reviewing any .go file, go.mod or go.work, upgrading the Go version, adding a Go dependency, or when a Go build, vet or test fails, even if the user never says "Go". Not for SQL, schema or pgx query design - use database; not for reviewing a whole diff against a spec - use `review`.
Instruments a feature so on-call can tell that it broke, where time went, and why, using logs, metrics, and traces, and designs symptom alerts. Includes a measured performance loop and caching rules. Use when adding logging, logs, structured logs, metrics, tracing, OpenTelemetry, spans, a correlation or request ID, alerts, an SLO, or on-call, when asking how we will know it broke, when instrumenting a feature, endpoint, job, or integration, or when the user mentions performance, a slow endpoint, latency, profiling, optimize, or caching. Not for diagnosing a live incident - use the debug skill where installed; not for creating alerts or dashboards in a specific backend - use that backend's skill; not for database query tuning - use database.
Audits a repo or an area of it for drift, duplication, divergent flows, reimplemented code, over-engineering, dead code and visible waste, then applies approved fixes one behaviour-preserving step at a time. Use when asked to refactor, clean up, standardize, deduplicate, remove dead code, or make an area consistent. Not for a security audit - use security; not for reviewing one pull request - use `review`; not for a new feature or a bug fix - use coding.
Threat-models a change that crosses a trust boundary, turns each abuse case into a failing test, triages a scanner or advisory finding, and writes a design review into the design doc. Use when adding or changing auth, login, sessions, cookies, passwords, tokens, JWT, permissions, roles, user input, file uploads, webhooks, a fetch of a user-supplied URL, secrets, API keys, CORS, CSRF, XSS, SQL injection, a vulnerability, a CVE, a dependency or npm audit finding, a threat model, personal data, PII, GDPR, or an LLM feature that handles untrusted text, or when the user asks whether something is secure. Not for reviewing a whole diff - use `review`; not for Go-specific APIs - use go; not for SQL or schema design - use database.
Use when asked for test cases, QA coverage, or how to test a flow by hand. Not for writing the test code or a security audit.
Use when writing or updating a pull or merge request title or body, adding screenshots or a diagram to one, or drafting replies to review comments. Not for pushing or opening the PR - use ship; not for reviewing someone else's PR - use `review`.
Add to your README
The badge links readers to this page. It shows the skilld mark and no counts, and it follows the reader's light or dark GitHub theme.
<a href="https://skilld.dev/gh/avik-creator/agent-skills">
<picture>
<source media="(prefers-color-scheme: dark)" srcset="https://skilld.dev/b/avik-creator/agent-skills?theme=dark">
<source media="(prefers-color-scheme: light)" srcset="https://skilld.dev/b/avik-creator/agent-skills?theme=light">
<img alt="Skill repository on skilld.dev" src="https://skilld.dev/b/avik-creator/agent-skills?theme=light">
</picture>
</a>