liuzhengdongfortest/codestable
26 skills23.9k installs23.5k starsGitHub
Install
npx skills add https://github.com/liuzhengdongfortest/codestableSkills in this repo
1Cs Feat Acceptcs-feat-accept is stage three of the CodeStable feature pipeline: after cs-feat-impl finishes, the agent runs a strict acceptance loop for solo builders documenting products in-repo. It reads `.codestable/attention.md` first, confirms implementation landed in git, validates the feature design document, then fixes deviations immediately instead of noting them passively in a report. You reconcile implementation against design sections (including fastforward layouts), merge outcomes into architecture center docs, upgrade or backfill requirement records, and mark roadmap items done when frontmatter points at them. Triggers match natural merge prep phrases in Chinese or English intent such as final check before merge. The skill is agent-native PM for people who already use CodeStable skeletons—not a generic linter. Finishing without acceptance.md leaves the next feature working off stale architecture and a lying roadmap.964installs2Cs Feat Designcs-feat-design is the first stage of the CodeStable feature pipeline: it turns a known problem, audience, and success definition into a durable design document and an actionable checklist. Solo and indie builders install it when they want agent-assisted feature design that does not dissolve into chat—you get a dated feature folder, structured markdown, and YAML tasks that later skills consume for implementation and acceptance. The skill distinguishes formal drafting from init mode (create the folder and an empty intent file for human-first writing) and from roadmap-driven starts that pull context from roadmap docs and update dependency status in items.yaml. Because errors at design propagate to build and ship, the workflow enforces attention.md and skeleton completeness before any judgment. It pairs naturally with prior brainstorm or intent work and replaces one-off design notes with repo-local artifacts your coding agent can reference across sessions.964installs3Cs Brainstormcs-brainstorm is the CodeStable discussion-layer entry for solo and indie builders when an idea is still fuzzy or direction is swinging. Before any feature-design or roadmap work, the skill triages the conversation into one of four cases—from already-clear ideas that skip straight to cs-feat-design, through single-feature brainstorm files, to multi-feature grill sessions or roadmap-ready decomposition. Every session starts by reading .codestable/attention.md and scanning existing architecture, features, roadmaps, and compound learnings so naming and scope do not collide with prior work. The agent is instructed to debate and explore rather than parrot user notes, and case boundaries are soft so scope can grow or shrink mid-chat. Outputs may land as slugged markdown under features/ or brainstorms/, or no file at all when routing immediately. It pairs with the broader CodeStable stack for agentic product development in Claude Code, Cursor, and similar environments.963installs4Cs Onboardcs-onboard is a CodeStable agent skill for solo builders who are adopting the CodeStable workflow in a repository for the first time or rebuilding a thin documentation skeleton. It materializes the canonical on-disk layout: a stub architecture entry, the mandatory attention.md gate that all sibling skills must read on startup, and the code-dimensions reference that design, fastforward, and issue-fix stages share for robustness, structure, performance, and readability defaults. The skill intentionally avoids inventing project-specific facts; owners fill substance later via cs-note and normal development. For agent users on Claude Code or Cursor, onboard reduces context drift by giving every subsequent skill the same paths and naming conventions documented in shared-conventions. Run it once early in Build when you want agent-assisted features to respect compile traps, path rules, and architectural boundaries instead of re-deriving them each session.963installs5Cs Explorecs-explore is a CodeStable agent skill that turns ad-hoc “read the repo until you understand it” into durable, searchable exploration documents. Solo builders onboarding to an unfamiliar codebase, or preparing feature design and issue work, invoke it when they need evidence before decisions. The agent picks one of three types—targeted question, module overview, or time-boxed spike—reads code with a fixed section template, and lands artifacts under .codestable/compound/ with structured frontmatter (slug, topic, scope, keywords, status, confidence). Speed matters on repeat visits: the skill assumes a second lookup should take minutes if the first pass was archived well. It deliberately stops at observation; if the user wants a fix or a signed design, they choose another CodeStable skill. Startup mirrors the family rule: read .codestable/attention.md or onboard first. Use it across early Idea research, Validate scoping, and Build prep before cs-feat-impl or issue flows so later agents inherit citations instead of re-walking the tree blindly.961installs6Cs Feat Implcs-feat-impl is the CodeStable agent skill for phase two of a feature pipeline: once a feature design is approved and a checklist exists, the agent walks paradigm-dimension steps, chooses concrete files per step, and reports progress in a unified format. It is built for solo and small-team builders who already adopted the .codestable repo skeleton and want implementation discipline—not freestyle coding. The skill encodes uncomfortable defaults: write the least code that satisfies the current step, do not beautify unrelated neighbors, and treat any design gap as a stop signal to renegotiate the design rather than improvising. Startup requires .codestable/attention.md; without it, the agent should onboard instead of guessing paths from generic templates. Frontmatter and structural checks on the design document (doc_type, status=approved, summary, tags, section 0–4 or fastforward variants) prevent implementation on half-baked specs. Triggers match explicit user intent to start coding after sign-off. It pairs naturally with prior design skills and keeps PRs reviewable by isolating functional diffs from drive-by cleanup logged as follow-ups.961installs7Cs Refactorcs-refactor is the CodesStable refactoring method library: a scan-phase lookup table and design-phase citation source so every execution step names a concrete technique instead of ad-hoc rewrites. Solo builders maintaining growing codebases use it when a scan flags hot spots—functions called from many sites, legacy modules to replace, or dependency swaps—and they need staged, test-backed moves. Layer L1 covers safe large-scale migration (parallel change, strangler fig, branch by abstraction). L2 maps classic single-shot refactors. L3 targets component and module boundaries. L4 addresses behavior-equivalent performance and async changes with complexity or IO metrics. Fields are unified across methods: applicability, anti-patterns, step lists, risk points, verification, and frontend/backend notes. It is multi-phase because the same discipline applies while building features, reviewing before ship, and iterating production debt.960installs8Cs Archcs-arch is the CodeStable entry point for drafting, refreshing, and health-checking your project’s architecture folder: a cumulative map of how the system actually works today. Solo and indie builders use it when someone asks to refresh architecture docs after code changes, verify a design still matches implementation, backfill missing module documentation, or satisfy a feature-stage gate that requires an architecture pass first. The skill enforces three modes—update, check, and backfill—inferred from what the user says, and it refuses to record roadmap-style future plans (those belong to cs-roadmap). It optimizes for accuracy, stability, and traceability so readers understand boundaries and rationale without chasing archived design files. Shared conventions live under `.codestable/reference/`; structural templates and check report formats are in companion reference docs. Treat architecture as the post-acceptance distillation of stable nouns, orchestration, and constraints from ephemeral design work.959installs9Cs Learncs-learn is a Codestable agent skill that turns finished feature and issue work into durable, searchable learning documents. Specs tell you what shipped; this skill records what hurt and what should become default practice—on pitfall and knowledge tracks—under .codestable/compound/ with consistent frontmatter. Solo builders and tiny teams avoid re-solving the same integration bug or rediscovering workflow tricks because Phase 1.5 mandates overlap checks and an update path instead of duplicate notes. It activates when acceptance or fix workflows offer a one-line prompt, when you explicitly ask to record learning, or after a one-off hard debug session. The skill reads attention.md first and refuses to pretend the repo is onboarded when the Codestable skeleton is missing. It pairs naturally with cs-feat-accept and cs-issue-fix as the compound step after delivery, keeping agent behavior aligned with shared-conventions tagging and archive rules.959installs10Cs Featcs-feat is the CodeStable entry point when you want a new capability to move from spoken intent to a verifiable ship, using on-disk artifacts as the contract between you and the agent. Before any routing decision, the skill insists on `.codestable/attention.md` or onboarding via cs-onboard so the repo skeleton is trustworthy. It exists because jumping from a one-line request straight to patches produces naming drift, scope creep, and no audit trail; the prescribed flow inserts design and checklist.yaml between requirements and code. Brainstorming is a separate door that triages three cases—ready for design, needs a brainstorm note, or needs roadmap-level planning. The skill names which subdirectory file is missing or stale and which child skill to invoke, keeping feature work under `.codestable/features/` isolated from issue work under `.codestable/issues/`. Solo builders using agentic coding on real products benefit when every feature folder becomes a searchable decision archive months later.958installs11Cs Issue Fixcs-issue-fix is the CodeStable execution skill for stage three of the issue pipeline: the root cause and fix plan are already agreed, and your job is to change code surgically, prove the bug is gone, and write a durable fix note. It opens from either the standard path after cs-issue-analyze or a fast channel when the report stage already captured enough detail. The skill’s central guardrail is resisting “while I’m here” optimizations that pollute the PR and erase blame clarity. You produce a fix汇报-style summary, rerun reproduction from {slug}-report.md, and persist either standard or fast-track fix-note templates under the issue directory. When the first patch fails, it documents a bounded logging ritual—mark probes, collect user-provided log slices, revise hypotheses, strip probes, and only then re-enter fixing; two failed log rounds trigger a handoff back to analysis. Solo builders using agent coding for production apps get a repeatable bug closure record instead of a mystery diff in chat history.958installs12Cs Issuecs-issue is the CodeStable entry for turning “something is broken” into a repeatable closure workflow. Solo and indie builders using codestable agents get a deliberate buffer between noticing a defect and editing code: discover the problem, capture it in `{slug}-report.md`, analyze root cause in `{slug}-analysis.md`, then fix and verify with a mandatory `{slug}-fix-note.md` plus code changes. The skill never implements fixes—it inspects which stage artifacts already exist and invokes `cs-issue-report`, `cs-issue-analyze`, or `cs-issue-fix` accordingly, including a fast channel when the issue is simple. That design fights the usual failure modes: forgotten repro steps, shallow fixes, scope creep, and missing acceptance criteria. It assumes the `.codestable` skeleton is in place (or `cs-onboard` first) and keeps all issue docs searchable via `doc_type` frontmatter for `search-yaml.py`.956installs13Cs Issue Analyzecs-issue-analyze is CodeStable’s phase-2 bug skill: turn a confirmed `{slug}-report.md` into an evidence-backed `{slug}-analysis.md`. Solo builders benefit because agents are forced to grep and trace real execution paths instead of narrating guesses from the report. The workflow walks five steps—pinpoint offending code with file:line notes, contrast normal vs failure paths, classify root causes (logic, state, concurrency, etc.), assess blast radius, then document two or three repair options with trade-offs for the human to choose. It resumes partial analyses, pulls compound/requirements/architecture context from `.codestable/`, and stops at a checkpoint without patching. That separation keeps scope decisions with the builder and sets up `cs-issue-fix` with a chosen direction. Startup requires the codestable skeleton and a complete confirmed report from `cs-issue-report`.956installs14Cs Decidecs-decide is a CodeStable agent skill that turns settled technical and process choices into durable decision documents so context does not evaporate between sessions or teammates. Solo and indie builders use it when they have finished a design or analysis thread and need an ADR-style record of what was chosen, why, which alternatives were rejected, and what tradeoffs follow. The skill enforces a consistent frontmatter schema (doc_type, category, date, slug, status) and body sections so agents and humans can grep `.codestable/compound/` instead of replaying Slack debates. It pairs naturally with design and analyze workflows: invoke after important choices, not while options are still open. Journey-wide in practice because constraints surface during validate scoping, build implementation, ship review, and operate iteration—even though new files are usually written during active build and docs work.953installs15Cs Feat Ffcs-feat-ff is CodeStable’s ultra-light feature channel for solo and indie builders who want the agent to code immediately when a request is too small for a full design pipeline. Instead of replacing fast implementation, it adds a disciplined pre-flight: glob `.codestable/`, query compound learnings and decisions, and respect architecture boundaries so quick patches do not repeat past mistakes. Triggers include fast mode, fastforward, or explicit requests to skip heavy steps. After implementation, the skill expects a minimal fast-forward note so work stays auditable and can feed architecture and requirements backfill. It pairs with cs-onboard when attention.md is missing and complements heavier CodeStable feat skills when scope grows.953installs16Cs Libdoccs-libdoc is a CodeStable documentation skill that builds reference-grade docs for every public entry in a library—Vue components, TS functions, CLI commands, or HTTP endpoints—using the repository as the sole source of truth. Unlike guidedoc, which teaches tasks, libdoc answers what each symbol exports, its types, defaults, and edge cases with one correct answer per field. A `manifest.yaml` lists entries, source files, doc paths, and review status so solo maintainers can batch-refresh stale pages after refactors. The agent must read each entry’s source independently rather than paraphrasing neighboring docs, reducing hallucinated props or flags. Triggers include user requests for API or component documentation and post-acceptance workflows when the public surface grows. It is multi-phase because you draft during build, refresh before ship, and mark outdated during operate—but the shelf remains build docs.953installs17Cs Issue Reportcs-issue-report is the CodeStable issue workflow stage 1: an agent skill that interviews you in Chinese (or mixed dialogue) and writes a reproducible, traceable `{slug}-report.md` while deciding whether the case qualifies for the fast fix channel or full analysis. It is built for solo and indie developers using Claude Code, Cursor, or similar agents inside a `.codestable` repo, not for ad-hoc chat bug threads. Triggers when you say you want to file an issue, log a bug, or describe a problem you found. The skill enforces “record symptoms, not assumed root cause” so stage 2 analysis is not biased by guesses. It checks for duplicate issues, validates bug vs feature intent, and only at this stage performs the single authorized fast-path code peek. You get a dated issue folder, clear reproduction steps, and an explicit handoff to `cs-issue-fix` on the fast path or to downstream issue stages on the standard path.952installs18Cs Trickcs-trick is a Codestable agent skill that turns fleeting implementation wins into durable, prescription-style reference docs inside `.codestable/compound/`. Solo and indie builders (and small teams using the same repo ritual) install it when they want one searchable library for how this project does Repository patterns, library APIs, or command recipes—not scattered chat notes. Invoke when someone says “记录一个技巧”, “tricks”, or when design or analyze work surfaces a reusable pattern worth keeping. The skill enforces shared frontmatter (`type`, `topic`, `status`, optional `superseded-by`), ties naming to dated slugs, and reads `.codestable/attention.md` before acting so agents stay inside the project skeleton. It pairs naturally with broader Codestable design and onboarding flows and keeps agents from defaulting to generic Stack Overflow answers during Build, then again during Ship reviews and Operate firefights.951installs19Cs Roadmapcs-roadmap is an agent skill that supplies a rigorous roadmap template for large software initiatives in stable codebases. Solo builders and small teams use it when a single ticket is insufficient and they must communicate background, boundaries, module boundaries, and non-negotiable cross-module contracts before anyone writes feature specs. The SKILL.md keeps a lightweight process skeleton while the reference template defines frontmatter, scope sections, ASCII-style module trees, and interface detail explicit enough to constrain downstream feature-design work. It is most valuable when several modules will evolve in parallel and ambiguity would cause rework. Tagged multi-phase because the same roadmap supports Validate scoping conversations, Build-phase program management, and Operate-era iteration reviews when status and last_reviewed dates are maintained.949installs20Cs Guidecs-guide is a CodeStable agent skill for writing and updating outward-facing guided documentation from specs and implementation. It targets solo and indie builders who ship features through a spec-driven workflow and need readers who will never open internal spec files to get role-appropriate guides instead. You choose dev-guide versus user-guide from who reads the doc—contributors and integrators versus terminal users—and the same feature often needs both when APIs change and user flows change in parallel. Triggers include explicit requests to write documentation, onboarding completion for a new repo skeleton, and a single optional nudge at the end of feature-acceptance when contract or user-visible sections changed; the skill stops pushing if the user declines. Outputs live outside .codestable as durable, slug-named markdown without date prefixes, aligned with CodeStable search conventions. It complements libdoc-style part reference by staying task-oriented: how to accomplish Y with X.948installs21Cs Refactor Ffcs-refactor-ff is the ultra-light channel of the CodeStable refactor workflow for solo builders who want a direct edit without the full three-phase ceremony. It activates when you say things like quick refactor, small optimization on one function, or ask to skip heavy steps—and only when the work stays inside a single function or component pocket with tests or type checks that can prove equivalence. Before anything runs, the agent must read `.codestable/attention.md`; if the CodeStable skeleton is incomplete, it stops and points you to onboard instead of improvising from generic prompts. Three entry checks mirror the spirit of a longer seven-item scan: no sneaky behavior changes, no large blast radius, and no proceeding without verification harness. Inside the fast path, every edit must map to a well-known refactoring move; exotic structural work routes to the full cs-refactor flow and method library. The interaction model is deliberately thin: align once, implement once, run tests, report briefly—ideal when you already know the smell and just need guardrails.947installs22Cs Reqcs-req is a CodeStable agent skill for maintaining capability vision documents in `.codestable/requirements/`, written so non-technical readers grasp why a capability exists, how it helps, and where it stops. Solo builders and small teams using the CodeStable skeleton invoke it when brainstorm settles a need (draft status), when feature-design needs a stable vision anchor, when acceptance proves a feature (update to current with change log), or when backfilling a live capability that never had a req file. It deliberately does not schedule sprints or decompose work—that is cs-roadmap. The skill enforces tone and structure against PRD field dumps, lecture-y explainers, and implementation leakage into vision docs. Reading shared conventions and the requirement example before drafting keeps outputs scannable. Confidence is high for teams already on CodeStable; others need onboarded paths first.947installs23CsThe `cs` skill is CodeStable’s workflow root router for solo and small-team builders who already use or want to adopt the `.codestable/` artifact system. Instead of guessing which `cs-*` skill applies, you invoke `cs` when input is open-ended—only the word `cs`, a request to explain CodeStable, or a fuzzy goal like adding auth or fixing a bug before the path is clear. The agent scans the repo for `.codestable/`, reads `attention.md` (blocking if incomplete), optionally loads the system overview, and glances at in-flight feature, issue, and roadmap folders so recommendations reflect real project state. It never performs downstream work: no writing specs, no editing compound knowledge, no running onboard or feature flows on behalf of child skills. When the user wants orientation, you get a concise map of entities and flows; when they have a concrete ask, you get a scene-to-skill routing decision with a short rationale. That keeps agent attention on the correct procedural skill while preserving CodeStable’s single source of truth under `.codestable/`.925installs24Cs Notecs-note is a CodeStable companion skill for capturing ultra-short project facts that must be true on almost every AI session—special compile steps, services to start first, path traps, command aliases, and env conventions. Instead of scattering these in chat or bloating retrieval-only notes, you append them to `.codestable/attention.md`, which CodeStable skills are required to read at startup. The skill enforces a clear routing table: cs-learn and cs-trick stay searchable markdown artifacts, while cs-note owns the tiny, stable, high-frequency layer. A simple decision rubric (one or two lines, every session, long-lived) plus a user sanity check (“will every session need this?”) keeps attention.md from becoming a junk drawer. Solo builders using CodeStable on messy real repos get fewer repeated mistakes and faster agent alignment without writing full specs for trivial constraints.764installs25Cs Auditcs-audit is a procedural audit skill for solo and indie builders who want repeatable code reviews instead of ad-hoc agent opinions. It defines two markdown deliverables—an audit index and numbered finding files—with frontmatter for scope, status, and severity. During a run the agent scans directories you specify, maps each issue to one of five nature types, assigns P0–P2 priority and confidence, and tabulates counts by dimension. The index ends with actionable buckets (fix P0 immediately, P1 this iteration, P2 when capacity allows). Each finding stays concise: one-line summary, key evidence with paths and lines, impact, and a one-line fix direction so implementation stays in separate skills. It pairs naturally with issue-tracking workflows in the same codestable family and is strongest when you already have a repo boundary and keywords or paths to focus the sweep.673installs26Browser BridgeBrowser-bridge is an agent-oriented Chrome extension skill centered on a background script that proxies cookie access, CDP invocations, batched operations, and tab lifecycle actions. Solo builders automating QA, scraping authenticated dashboards, or demoing SaaS flows install it when they need an in-browser control plane rather than only headless Playwright. On install it registers a high-priority rule that removes Content-Security-Policy response headers on main and sub frames—a deliberate tradeoff so injected or evaluated scripts can run in restrictive sites during development. Handlers return structured ok/data envelopes for tab creation, focus changes, and teardown. The skill spans Build integrations and Ship testing because the same bridge supports integration coding and later automated checks against production-like sessions. Treat CSP stripping and CDP power as high-trust capabilities limited to dev profiles.508installs