cold-start
Bootstrap a Memory Bank for a new or existing repository, then route into PRD-driven or brownfield workflows.
How do I install this agent skill?
npx skills add https://github.com/mrvladd-d/memobank --skill cold-startIs this agent skill safe to install?
- Gen Agent Trust Hubpass
This skill bootstraps a project management structure called 'Memory Bank' by creating directories, templates, and agent configurations. It is functional for orchestrating repository analysis but possesses a minor risk due to the processing of external project data (PRDs and code) which can lead to indirect prompt injection.
- Socketpass
No alerts
- Snykpass
Risk: LOW · No issues
- Runlayerfail
16/47 files flagged
What does this agent skill do?
Cold Start: Memory Bank + Agents bootstrap (greenfield & brownfield)
Summary
Note:
cold-startis the package skill for all-in-one bootstrap. Do not confuse it with the generated project command/cold-start: that command is a lightweight router used after skeleton creation inside a target repo. For modular usage, prefer individual skills:mb-init(skeleton),mb-analysis(optional idea discovery),mb-from-prd(greenfield),mb-map-codebase(brownfield),mb-review(review),mb-execute(implementation),mb-verify(UAT),mb-red-verify(semantic adversarial verification).
- What it does: creates the Memory Bank skeleton, writes agent entry points, and routes the repo into the right workflow.
- Use it when: you want one entry point for either a new project with a PRD or an existing codebase that needs mapping first.
- Input: repository root plus either
prd.md/ requirements text or an existing codebase. - Output:
.memory-bank/,.tasks/,.protocols/, agent entry files, and the next step for greenfield or brownfield work.
Supported scenarios:
- Idea-only: repo has a raw idea, but no stable PRD yet; optionally route through
/analysis,/brainstorm, and/brief. - Clear concept: repo has enough direction for a product brief; normally run
/brief, then/constitutiononly if project principles are not alreadyratified|partial, before/write-prd. - Greenfield: repo has
prd.mdor requirements text, but no code yet. - Brownfield: repo already contains code and needs as-is documentation before change planning.
Non-negotiable principles
1) Orchestrator vs workers
- You (main agent) are the orchestrator. You plan and coordinate.
- Workers (subagents) do the heavy lifting (scanning many files, producing long reports).
- Max depth = 2: orchestrator → subagent. No sub-sub-agents.
2) .tasks/ is runtime memory (НЕ Memory Bank)
- Every agent process gets a unique task folder:
.tasks/TASK-XXX/. - Subagents write detailed outputs there, and return only short summaries to the orchestrator.
3) Avoid conflicts by design
- Split work by non-overlapping file sets.
- If overlap is unavoidable, use git branches/worktrees per agent and merge later.
4) Parallelism limits
- Run up to 5–7 subagents in parallel.
- If your runtime supports multi-tool calls: spawn parallel subagents in a single orchestrator turn.
5) Docs First
After completing any meaningful unit of work:
- Update Memory Bank while context is fresh.
- Then change code / commit.
Output you MUST create/maintain
Repo root
AGENTS.md(canonical, short, ~100 lines)CLAUDE.md→ symlink (or copy) toAGENTS.md- (optional)
GEMINI.md→ symlink (or copy) toAGENTS.md
Repo folders
.memory-bank/— durable knowledge base.tasks/— operational runtime memory.protocols/— file-based protocols (plans / decision logs / resume)
Step 0 — Detect environment (don’t guess)
-
Check what tools you have:
- Codex available? (Codex CLI / MCP tool)
- Claude Code available? (CLI
claude, subagents) - Browser tools? (Playwright / agent-browser / CDP MCP)
-
Decide primary engine:
- If working inside Codex: use
gpt-5.2-highfor implementation and review (prefer fresh sessions for critical reviews). - If working inside Claude Code: use subagents for analysis + use Opus for synthesis; optionally call Codex via shell for second opinion or structured review.
- If both Codex and Claude are available (dual-engine): use Claude for wide-context scanning and synthesis, Codex for structured review and implementation. Cross-validate critical outputs (MB compliance, architecture) by running the review step on the other engine. See Step 4 for the hybrid workflow.
- If working inside Codex: use
If you don’t control Codex model selection via UI, create a project
.codex/config.tomlprofile set (see Step 1.5).
Step 1 — Bootstrap the skeleton
1.1 Create directories
Create (if missing):
-
.memory-bank/mbb/architecture/guides/adrs/tech-specs/domains/(optional but recommended)contracts/(optional but recommended)states/(optional but recommended)runbooks/(optional but recommended)workflows/(optional; can keepwfs/if you already use it)quality/(optional but recommended)testing/skills/epics/features/schemas/(JSON schemas, including task records)tasks/(empty JSON task index until/prd-to-tasks, indexed task records, and plans)commands/(slash-command specs used by humans/agents)agents/(subagent prompt library)archive/bugs/
-
.tasks/ -
.protocols/
1.2 Create core files (use the templates)
Use the templates in:
./references/shared-structure-template.md
At minimum you must create:
AGENTS.mdCLAUDE.mdsymlink/copy.memory-bank/index.md.memory-bank/constitution.md.memory-bank/mbb/index.md.memory-bank/spec-index.md.memory-bank/glossary.md.memory-bank/invariants.md.memory-bank/product.md.memory-bank/requirements.md.memory-bank/schemas/task.schema.json.memory-bank/tasks/index.json.memory-bank/testing/index.md
Also create the command specs under .memory-bank/commands/ (use references/commands/*).
This includes optional Analysis commands (analysis.md, brainstorm.md, brief.md) when those command specs are present in the package.
It also includes constitution.md for the /constitution command, which creates or updates .memory-bank/constitution.md.
1.2.1 Create native skills (proxy commands)
Create thin proxy skills so commands work natively in each runtime:
.claude/skills/<name>/SKILL.md→ Claude Code + OpenCode.agents/skills/<name>/SKILL.md→ Codex CLI + OpenCode
Each proxy just says: Read and follow the instructions in .memory-bank/commands/<name>.md.
This makes commands available natively (/mb, /constitution, /prd, /execute, etc.) in all three tools.
The init-mb.js script creates both sets automatically.
Agents read .memory-bank/constitution.md early during priming. It is the short governing-principles layer for project decisions, not a replacement for .memory-bank/invariants.md, .memory-bank/contracts/*, .memory-bank/spec-index.md, or tier/workflow policy.
1.3 Enforce frontmatter rule
Every markdown file inside .memory-bank/ must include YAML frontmatter with at least:
description: ...status: draft|active|deprecated|archived
1.4 Create .tasks/ protocol
Create a task folder for this run (pick a new id):
.tasks/TASK-MB-INIT/
Inside it, create:
TASK-MB-INIT-S-00-orchestrator-plan.md— what you will do + which subagents
1.5 Optional: Codex profile presets
If Codex is used, create .codex/config.toml with profiles:
- default: coding (gpt-5.2, high)
- profile
deep-review: review (gpt-5.2, xhigh)
(If your repo is shared, consider keeping it local or documenting it in .memory-bank/runbooks/.)
Step 2 — Choose scenario
Decision rule
- If repo has substantial code (
src/,package.json,go.mod,Cargo.toml, etc.) → Brownfield (Step 3B). - If repo is mostly empty and you have
prd.md→ Greenfield (Step 3A); recommend/constitutionbefore/write-prdif project principles are not ratified/partial. - If repo is mostly empty and you only have an idea or loose concept → optionally run Analysis first:
/analysis,/brainstormwhen the idea is raw,/brief, then/constitutionbefore/write-prdonly if project principles are not alreadyratified|partial. - If both exist: treat as Brownfield + PRD delta (Step 3B).
- If repo is empty/new and no
prd.md→ Skeleton-only (Step 3C).
Record the scenario in:
.tasks/TASK-MB-INIT/TASK-MB-INIT-S-00-orchestrator-plan.md
Step 3A — Greenfield workflow (PRD → Memory Bank)
3A.1 Write clarified PRD
- Run
/constitutionbefore/write-prdwhen project principles are still framework-default/skipped/missing. If they are already ratified/partial, continue directly to/write-prd./constitutionreads.memory-bank/analysis/product-brief.mdwhen present and asks up to 5 contextual governance questions per pass. - If the user explicitly skips
/constitution, continue with framework-default/skipped principles and note that it can be ratified later. - Run
/write-prdto turn Product Brief / PRD text + Constitution into.memory-bank/prd.md. /write-prdhandles PRD-level ambiguity with up to 5 targeted questions per pass.- If PRD mentions “use skills/tools/CLIs” — run
/find-skillsfirst (project-installed → marketplace).
If user is temporarily unavailable (“запуск и ушёл”):
- Record
Open questionsin.protocols/PRD-BOOTSTRAP/decision-log.md. - Stop and wait (do not invent facts; do not proceed to EP/FT/task generation without answers).
If the user explicitly wants autonomous mode:
- record non-blocking gaps as
Assumptions - halt only on blocking gaps (security/compliance/external contract/data-loss risks)
- continue with
/autonomousafter/write-prdis complete
3A.2 Route PRD to L1–L3
Run /spec-init to update .memory-bank/spec-index.md as a lightweight SDD route map from PRD/brief/existing-spec evidence, without architecture interview or invented authoritative specs.
Then run /prd to decompose .memory-bank/prd.md into product, requirements, epics, features, testing, and index updates.
After /prd, always run /spec-design. For small independent T0/T1 features it may record a minimal backbone with irrelevant areas marked not_applicable; for shared/T2/T3 concerns it creates or updates the needed backbone SDD specs and spec-index. This is not another mandatory heavy phase: it creates no tasks and no feature-local implementation design. /spec-improve FT-<NNN> remains the feature-level gate after backbone.
/prd owns:
.memory-bank/product.md- REQ-IDs
- RTM table mapping REQ → Epic → Feature → Test
.memory-bank/epics/EP-*.md.memory-bank/features/FT-*.md
Each generated feature MUST include:
- use cases
- acceptance criteria
- failure modes / edge cases
- test strategy pointers
Status policy:
- Default EP/FT frontmatter to
status: draftuntilOpen questionsare resolved. - Promote to
status: activeonly when acceptance criteria + verification plan are stable. /prd/mb-from-prddo not create tasks; canonical planning path is/write-prd→/spec-init→/prd→/spec-design→/spec-improve FT-<NNN>→/prd-to-tasks FT-<NNN>.- Add feature
clarification_status: pending|blockedonly for explicit feature-level blockers.
3A.3 Tasks planning (per-feature, no “everything at once”)
Do not generate a full task queue for all features in one pass.
Instead:
- Ensure
.memory-bank/schemas/task.schema.jsonand.memory-bank/tasks/index.jsonexist. - For each selected feature, use
/clarify-feature FT-<NNN>only if the feature is explicitly pending/blocked. - Run
/spec-designafter/prd; use minimal backbone for simple T0/T1 scope and fuller backbone specs for shared/T2/T3 concerns. - Run
/spec-improve FT-<NNN>, then/prd-to-tasks FT-<NNN>to produce:.memory-bank/tasks/plans/IMPL-FT-<NNN>.md- atomic
.memory-bank/tasks/TASK-*.task.jsonrecords grouped bywave, each with mandatorytier: T0|T1|T2|T3
Task routing is authoritative only through task.tier; the old risk / risk.level model is invalid.
3A.4 Identify key concepts and create support docs
For every non-trivial concept, create support docs that make the concept cheap to reload later:
- default / compatibility path:
.memory-bank/architecture/<concept>.md(WHAT/WHY).memory-bank/guides/<concept>.md(HOW)
- add spec-driven support docs when they clarify source-of-truth:
.memory-bank/tech-specs/....memory-bank/contracts/....memory-bank/domains/....memory-bank/states/....memory-bank/adrs/....memory-bank/runbooks/....memory-bank/testing/...
Rules:
- classic duo docs remain valid and useful
- spec-driven docs are additive, not a replacement by default
- do not create a new spec before checking existing specs through
.memory-bank/spec-index.md - if richer docs exist, route them from
.memory-bank/spec-index.mdand related concept docs
3A.5 Update index
Update .memory-bank/index.md with annotated links to all created docs.
Step 3B — Brownfield workflow (Repo → Memory Bank)
3B.1 Spawn repo-scanning subagents (parallel)
Create a new task folder:
.tasks/TASK-MB-MAP/
Spawn up to 5 subagents in parallel with non-overlapping scopes:
S-01: build/tooling (package managers, scripts, CI)S-02: backend/servicesS-03: frontend/UIS-04: data layer (DB, migrations, schema)S-05: tests + quality gates
Each subagent MUST:
- verify its file glob targets exist ("smart calling")
- write a detailed report into
.tasks/TASK-MB-MAP/using naming:TASK-MB-MAP-S-0X-final-report-<code|docs>-YY.md - return a 5–10 line summary + file list
Use ./agents/shared-repo-scanner.md as baseline prompt, but scope it.
3B.2 Synthesize Memory Bank from reports
Using the .tasks/TASK-MB-MAP/ reports, fill:
.memory-bank/product.md— what the system is today.memory-bank/architecture/— C4 L1–L3 overview + key invariants.memory-bank/spec-index.md/.memory-bank/invariants.md/.memory-bank/glossary.md— if the evidence supports explicit normative routing.memory-bank/runbooks/— setup, dev, test, deploy.memory-bank/contracts/— API/event contracts.memory-bank/states/— lifecycle/state rules when they are evident from code or workflows.memory-bank/testing/index.md— canonical gates + verification notes.memory-bank/index.md— annotated links
PRD-less rule (non-negotiable): if there is no
prd.md, you MUST NOT create or populate:
.memory-bank/epics/*.memory-bank/features/*.memory-bank/tasks/*.task.jsonwith real roadmap tasksEmpty skeleton files/folders are allowed if they were created by bootstrap.
Repo mapping is as-is documentation, not roadmap planning. If something cannot be derived from code/logs/tests, record it as a hypothesis or an open question.
3B.3 Ask user for PRD delta
After baseline MB exists:
- ask the user for
prd.mddescribing what to change/add - run
/constitutionfirst only if project principles are not ratified/partial, then/write-prd,/spec-init,/prd,/spec-design,/spec-improve FT-<NNN>, and/prd-to-tasks FT-<NNN>style decomposition against the existing baseline
Step 3C — Skeleton-only workflow (no PRD, no code)
When the repo is new/empty and no prd.md is available:
3C.1 Create skeleton only
Run Step 1 as usual — create all directories, core files from templates, AGENTS.md, CLAUDE.md symlink.
The skeleton provides a ready-to-fill structure: product.md, requirements.md, tasks/index.json, etc. remain as draft stubs/placeholders.
In PRD-less mode, tasks/index.json must be { "version": 1, "tasks": [] } and no TASK-001.task.json or other runnable task record is generated.
3C.2 Ask for PRD
After skeleton is created, ask the user to provide a PRD:
"Memory Bank skeleton created. To fill it with product details, epics, features, SDD design, and task records, please provide a
prd.mdfile (or paste requirements text). You can do this now or later — run/constitutionfirst only if project principles are not alreadyratified|partial, then/write-prd,/spec-init,/prd,/spec-design,/spec-improve FT-<NNN>, and/prd-to-tasks FT-<NNN>."
3C.3 Wait or proceed
- If user provides PRD now → continue to Step 3A (Greenfield workflow).
- If user defers → stop here. The skeleton is valid and usable. The user can invoke
$mb-from-prdor/prdlater to fill the Memory Bank. - If user provides partial info → route it through
/brief, then/constitutiononly if project principles are not alreadyratified|partial, and/write-prd; stop if PRD-level blockers remain.
Note: The skeleton-only state is a valid stopping point.
AGENTS.md+.memory-bank/index.md+ MBB rules are enough for agents to start navigating the repo.
Step 4 — Hybrid mode (Claude ↔ Codex)
If you’re in Claude Code but want Codex quality or long-horizon autonomy:
- Use Claude subagents to produce the scan reports into
.tasks/TASK-MB-MAP/. - Call Codex via shell to synthesize Memory Bank:
codex exec --ephemeral --full-auto -m gpt-5.2-high \
'Read .tasks/TASK-MB-MAP and build/refresh .memory-bank per MBB. Keep AGENTS.md short. Produce a summary and run a self-review.'
- Then run a Codex deep review profile (or a fresh Claude session) for 5-expert review.
Step 5 — Multi-expert review loop (fresh context)
Run fresh-context reviewers (do not reuse the writer context):
- Architect (C4 + dependencies)
- Scope analyst (REQ → Epic → Feature → Task coverage)
- MBB compliance reviewer (frontmatter, links, atomics, duo)
- Plan reviewer (task record quality, waves, gates)
- Security reviewer (auth, sensitive data, OWASP risks)
- Code quality reviewer (conditional: if code exists — quality gates, conventions, hotspots)
Use prompts in ./agents/shared-review-*.md and ./agents/shared-mb-reviewer.md.
Rules:
- If any reviewer returns REJECT → fix MB and repeat review.
- Persist reviewer reports into
.tasks/TASK-MB-REVIEW/.
Step 6 — Start executing tasks
After review gate passes (APPROVE):
- Pick the highest-priority ready task from
.memory-bank/tasks/index.jsonand its indexed.task.jsonrecords. If the index is empty, stop and run/spec-design, then/spec-improve FT-<NNN>and/prd-to-tasks FT-<NNN>for a selected feature. Use/clarify-feature FT-<NNN>first only if that feature is explicitly pending/blocked. - Run
mb-executefor the task (plan → implement → quality gates → MB-SYNC). - Route by
task.tier:T0/T1may use compact verification inrun.md;T2/T3requiremb-verifyandmb-red-verify. - For
T3, require human-aware checkpoint plus rollback/recovery note before closure. - Repeat until the wave is complete or user stops.
If the intended mode is unattended end-to-end:
- do not stay in manual loop here
- switch to generated project command
/autonomous
If
mb-execute,mb-verify, ormb-red-verifyare not installed, follow their SKILL.md manually.
Definition of done
You are done when:
AGENTS.mdexists, short, points to.memory-bank/index.md.CLAUDE.mdis a symlink/copy ofAGENTS.md..memory-bank/contains at minimum: index + MBB + product + testing (requirements can remain as stubs until PRD exists)..memory-bank/constitution.mdexists and/constitutionis available for governing-principles updates..tasks/contains scan/review artifacts with naming + stage ids.- Greenfield: epics/features/task records created from PRD.
- Brownfield: repo mapped as-is into MB and user asked for PRD delta (no roadmap entities invented without PRD).
- Skeleton-only: skeleton created, user asked for PRD (valid stopping point).
- Multi-expert review passes (APPROVE) — for Greenfield/Brownfield; skip for Skeleton-only.
- Execution loop is available (mb-execute + mb-verify reachable or documented, plus mb-red-verify for T2/T3 tasks).
- Autonomous loop is available (
/autonomous+/autopilotdocumented).
References in this skill
./references/shared-structure-template.md./agents/shared-repo-scanner.md./agents/shared-mb-reviewer.md./agents/shared-review-architect.md./agents/shared-review-scope.md./agents/shared-review-code.md./agents/shared-review-plan.md./agents/shared-review-security.md./scripts/shared-init-mb.js(optional helper)
How can the creator link this skill?
Add the canonical catalog link to the repository README so users can inspect current installs and available audits. The publishing guide covers the complete discovery path.
<a href="https://skillzs.dev/skills/mrvladd-d/memobank/cold-start">View cold-start on skillZs</a>