agentsclimarketplace

Do project setup

Skill rizkyalfauji11/alpha-sdlc/skills/do-project-setup

Generate the project profile — the baseline "basics" docs (architecture, tech stack, database, environment, API map, security, CI/CD, assets, etc.) that grooming and every downstream skill ground in. Drafts the docs one at a time with your approval; has a refresh/reconcile mode to keep them current. Use to set up a project, bootstrap project docs, generate the project profile, or before the first grooming. **Also the FIRST step for a brand-new project**: on an empty repo it switches to greenfield mode and decides the stack (framework, architecture, structure, tooling) with the user, one gate per decision — then hands off to do-foundation-grooming for the scaffold. Triggers on "project setup", "generate project docs", "project profile", "set up the basics", "/do-project-setup", "onboard this repo", "start a new app", "new project from zero", "greenfield", "bootstrap the project".From its SKILL.md

Install
npx -y skills add rizkyalfauji11/alpha-sdlc --skill do-project-setup

Assembled from the repository path, not quoted from the project. Check it against their README if it does not work.

2 things to look at

  • no licenseNo license file was found in the repository. Code published without one is not open source by default, so using it at work is a question for whoever answers licensing questions where you are.
  • 2 stars2 stars. Stars are a popularity signal and not a quality one, but at this level it is likely that nobody has read this closely except its author, and you would be relying on your own review.

SKILL.md

17.1 KB, as published. Nobody here has run it

You are generating the project profile — the baseline reference every other skill grounds in, so grooming/planning/testing don't re-derive the same orientation each run. Output goes to ./docs/basics/. Run once per repo to bootstrap; re-run in refresh mode to keep it current.

First, read ../../principles.md in full now, then apply it — especially: ground in real code (never fabricate — mark anything you can't determine as UNKNOWN — needs human input, don't guess), draft + human-approve, and never over-simplify.

Rules

  • Empty repo? Switch to greenfield mode (below) — describing gives you 19 docs of UNKNOWN; deciding gives the project a foundation to be built against. Everything else in this skill still applies.
  • Full-project scan — no sampling. Learn the whole project, not a representative subset. Walk every module/package/directory, every manifest and config, all migrations, the entire asset tree — don't infer the architecture from a few modules or stop at the first pattern you recognize. This is the one skill where completeness outranks laziness: the profile is grounding truth for every later phase, so a partial scan quietly corrupts everything downstream. If the repo is too large for one pass, scan it systematically in parts until fully covered (module by module, optionally fanning out with parallel/Explore sub-agents) — never mark a doc complete from a partial view. If a section is unavoidably based on incomplete coverage, say so explicitly rather than guessing.
  • One doc at a time, with approval. Draft a doc → present it → user approves / edits / skips → only then write it to ./docs/basics/<file>.md → move to the next. Never batch-write all docs.
  • Tier — generate only what applies. Skip docs that don't fit this repo (e.g. ui-architecture / asset-registry on a backend repo) and say so; never emit empty filler files. Confirm the applicable list with the user first.
  • Point, don't copy volatile detail. Dependency versions, full DB DDL, pipeline YAML, env values → summarize + link the authoritative file. Cache the slow-changing orientation (architecture, conventions, base-URL matrix).
  • Never write secrets. Record where/what-name (config file, env-var name), never values, tokens, or keys.
  • Stamp each doc with the git commit it was generated at (in the doc header) — so refresh can tell which docs are stale without regenerating all 19. Greenfield exception: a pre-code doc is stamped prescriptive (pre-code) · <date> instead (see Greenfield mode) — a commit stamp on a doc whose code doesn't exist is a false claim that it was read.
  • 12-security-compliance.md is stricter: document only observed controls; never assert a compliance status you can't verify; flag every unconfirmed item as a gap for a human/security to fill; require an explicit human sign-off before writing it.

The docs (./docs/basics/)

Each doc has a starter template in this skill's templates/ directory (templates/<file>) — read the relevant one and fill it from the real project. Keep the header commit-stamp; drop template sections that don't apply.

FileContentsCache vs point
01-overview.mdProject summary, the profile index (links), per-doc freshness/commit stampscache
02-architecture.mdArchitecture style + layering + dependency rule, full code structure (complete directory tree — every dir annotated + significant files + feature boundaries, not sampled/elided), layer interaction & wiring patterns (how a call crosses each boundary — interface→impl→DI binding, async, errors, mapping, common-code consumption — per platform, with real examples), module/package map (module · feature · deps), key components (Mermaid)cache
03-ui-architecture.md (clients)Navigation, UI-state management (server state → data-cache), design-system component inventory (search-before-build, register-on-create), screen scaffolds & layout patterns (header anatomy · body slicing · dividers — learned from the real screens, register-on-create), theming, screen inventory (flows grouped)cache
04-ux-conventions.md (clients)App-wide interaction behavior — form validation & submit enable/disable, mandatory marking, empty/loading/error states, snackbars, confirmations, disabled affordance, a11ycache; cross-links ui-architecture
05-tech-stack.mdLanguages, frameworks, approved library per concern (reuse-before-add lookup), code generation (typed-client command), build tooling + build/run/test commandsstack cached; versions → manifest
06-domain-model.mdLogical entities + relationships + cross-feature ownership (owner = source of truth; consumers read via owner) — the shared truth interdependent features bind to; flags cross-feature contradictionscache; cross-links database/api-reference/feature-map
07-database.mdEngine(s), complete schema — every table/column/FK with on-delete actions (must match domain-model edges), indexes — no sampling, migrations, seed/test datafull mirror cached; migrations = executable truth
08-data-cache.mdLocal persistence (incl. flow drafts), caching strategy, shared server-state sync (query keys · mutation→invalidation · real-time events), offline behaviorcache
09-environment.mdEnvironments, config & secrets approach (names/locations), full-stack run recipe (per-service start command, ready-check, FE→BE wiring, CORS — feeds the integrated Boot & Smoke gate), feature flags, build variantsapproach cached; values → config files
10-conventions.mdCoding conventions, naming, folder rules, error handling & logging, data contract & localized rendering, testing conventionscache
11-git-management.mdBranching, commit/PR/merge conventions, protected branches, tags/releases, hookscache; release/version → cicd-deployment
12-security-compliance.mdAuth/authz, PII/data classification, encryption, compliance regimes, secret mgmt, security testing, audit loggingcontrols cached; policy → policy docs; strict sign-off
13-auth.md (if it authenticates)Runtime token handling — scheme, tokens (type/lifetime/storage/attach), refresh flow (rotation, single-flight), 401/expiry (refresh-and-retry, no loop), logout/revocation, multi-tab/devicemechanics cached (no secrets); cross-links security-compliance/api-reference/environment
14-cicd-deployment.mdCI/CD tool + pipeline stages, environment promotion, release process, versioning, rollbackshape cached; config → pipeline files
15-api-reference.mdBase-URL matrix (service × environment), machine-checkable contract (OpenAPI/schema location + owner + whether clients derive typed client/fixtures from it), API catalog (consumed/exposed, auth, owner, version), gotchas, error/retry conventionsmatrix cached (no secrets); defined-in → config
16-feature-map.mdCatalog of the app's features — purpose, entry points, owned endpoints/tables, depends-on, status, dependency graphinventory cached; detail → each feature's TRD
17-asset-registry.md (clients)Searchable inventory of registered assets (name · description · path per platform · tags), naming conventions, icon set, font filesinventory cached; token names/values → 18-design-tokens
18-design-tokens.md (clients)The enumerated visual contract — names and values: base unit + spacing scale & named roles, typography ramp + emphasis rules, font families & fallbacks, semantic color roles (light/dark), borders/dividers/hairlines, radius/elevation, icon & control sizing, grid/breakpoints, approved deviations, enforcementvalues mirrored (Figma stays upstream); contradictions flagged
19-code-inventory.mdEvery reusable code unit in the whole project — wherever it lives, not just core/common (helpers, extensions, base classes, wrappers, hooks): name · plain+engineer description · location · used-by; duplicates flagged as contradictions; promotion rule (to core at the second consumer)inventory cached; register-on-create; rung-2 lookups run here

Flow

Present every gate below in the shared step-summary format (principles.md): header (development · phase · step · status) · What (plain + engineer phrase) · Why (leads whenever a question is asked) · Who · When · Where · How (ends with what I need from you) · engineer detail last.

  1. Full scan & confirm. Scan the entire project (per the full-scan rule — every module, not a sample) to identify the repo type/platform and which docs apply (tier). Present the applicable doc list and get the user to confirm before drafting. If the scan finds no real source, say so and switch to greenfield mode (below) — confirm that with the user before deciding anything.
  2. Per doc, in order: scan the relevant real sources → draft the doc (mark UNKNOWN where undetermined; point to authoritative files for volatile detail) → present for approval (approve / edit / skip) → write to ./docs/basics/<file>.md with the commit stamp → next doc. 12-security-compliance.md needs explicit human sign-off. Seed 17-asset-registry.md by scanning the actual asset directories. Seed 16-feature-map.md from any existing docs/development/*/TRD.md (each is a feature) plus the code's feature modules/routes — capture their depends-on edges; if the app has no discernible features yet, start it minimal and note it. Seed 03-ui-architecture.md's screen scaffolds by scanning the real screens for recurring anatomy (header composition, body slicing ratios, dividers) — describe the patterns found, flag screens that contradict each other, and establish the intended scaffold with the user where none is consistent. Seed 18-design-tokens.md by extracting the real values in use — read the theme/tokens file(s) first, then sweep the actual screen/component code for spacing, font size/weight/family, color, border-thickness, radius and icon-size values, and mirror names and values (per platform: dp/sp · pt · rem/px). Where the same purpose has contradictory values (body text at 13/14/15sp across screens), do not pick silently: fill the Contradictions found table with the value histogram and ask the user to canonicalize, noting that migrating existing screens is do-tech-debt-grooming work, not a feature-time rewrite. A value that exists only in Figma is UNKNOWN — needs human input — never inferred from a mockup. If the project has no token file in code, say so, keep the doc-level scale authoritative (it's still enforceable), and record extracting one as recommended tech-debt. Also fill Enforcement with the project's real commands — and where no screenshot-baseline tool exists, record that limitation instead of inventing a gate. Seed 19-code-inventory.md with a full-project sweep for reusable units — every module, never just core/common (helpers, extensions, base classes, wrappers, hooks, validators): register each (plain+engineer description · location · used-by), and put the same job implemented more than once into its Duplicates table as a contradiction to canonicalize — never pick one silently. Seed 06-domain-model.md by extracting the core entities, relationships, and which feature owns each from the real schema/models/API — and per the codebase-state-agnostic principle: describe what exists, establish missing entities/relationships with the user, and flag contradictions (the same entity modelled two ways across features) in its Contradictions section rather than smoothing them over.
  3. Finish. Write/refresh 01-overview.md as the index with each doc's stamp. Report what was generated and what was skipped (and why).

Greenfield mode — a project from zero

When the repo is empty or has no real source yet (or the user says they're starting from zero), this skill flips from describing to deciding. Announce the mode explicitly before anything else — the docs it produces are intent, not observation, and every downstream skill needs to know that.

  • Decide with the user, one gate per decision. Each decision is its own approve/edit gate with 2–3 real options and one marked as the recommendation + its tradeoff (per principles.md) — never a batch sheet, never an assumed default. The decision set: product/service intent · platforms · repo strategy (monorepo vs separate repos) · language + runtime + framework per platform (pinned) · architecture style (and whether layering is used) · folder-structure convention · persistence/storage (if any) · API style + machine-checkable contract format · auth approach (if any) · testing stack · lint/format · CI/CD + hosting · config & env approach · git/commit conventions. Skip any that genuinely don't apply and say so.
  • Write all applicable docs, prescriptively. The tiered set is generated as the intended design, so grooming binds to a full picture instead of a stub. Two hard limits keep this from becoming fabrication:
    • Stamp them prescriptive (pre-code) + the date, in place of the commit hash — a commit stamp would claim the code was read. Add one line at the top of each: "Intended design, not observed — nothing is built yet."
    • Never invent a fact a feature hasn't created. Concrete schemas, endpoint catalogs, screen inventories, asset entries, and token values don't exist yet: write the decided approach (engine, naming, contract format, structure) and mark the specifics deferred — established when the first feature needs it. A prescriptive doc records decisions; it does not hallucinate content.
  • 12-security-compliance.md stays gaps-only. Nothing is observed in a greenfield repo, so it can assert no controls — record the intended approach plus every open gap, and keep the human sign-off requirement.
  • 16-feature-map.md starts empty. The foundation is not a feature; the first product feature registers itself when do-grooming runs.
  • Hand off to do-foundation-grooming — it grooms the scaffold, folder structure, and architecture skeleton into a foundation TRD that binds to these decisions by link. Stack decisions belong here, in the profile; if foundation grooming exposes a wrong or missing decision, it comes back to this skill rather than being re-decided there.
  • After the base is built and green, run refresh mode to re-stamp the prescriptive docs against the real commit — flipping them from intent to description, and flagging anywhere the built code diverged from what was decided (flag it; don't silently rewrite the decision to match the code).

Refresh / reconcile mode

This is also the end-of-feature reconcile the pipeline calls after a feature's SDLC completes (do-testing green): run it whenever a feature ships so docs/basics/ reflects what was built before the next feature grooms against it. Pay special attention to feature-map (register the new feature + its dependencies), api-reference, ui-architecture/ux-conventions, and auth.

Re-running on an existing profile: per-doc, compare the repo against the doc's commit stamp; refresh only the stale docs (with approval). For 17-asset-registry.md, reconcile — diff the registry against the actual asset directories and flag unregistered assets (added without registering). For 18-design-tokens.md, reconcile too — diff the doc against the theme file and sweep the code for raw literals (spacing/size/weight/hex/border values written outside the tokens): each one is either a token that was never registered or drift to report, and any new contradiction goes back into Contradictions found. A token doc that silently disagrees with the code is worse than none — the builder trusts it. For 19-code-inventory.md, reconcile — sweep for reusable units created since the stamp but never registered, and for new duplicates of an already-registered job. Fast-rot docs (tech-stack, database, cicd, api-reference) warrant aggressive checks; slow-rot docs (architecture, conventions, security) rarely change.

Keep looking

Skills are one crate of 609,689. Ordering is by how many stacks a row turns up in, so the top of any crate is what has actually been picked rather than what has the most stars.