agentsclimarketplace

Architecture blueprint

Skill codexskills/agent-forge/skills/architecture-blueprint

Production-grade AI agent skills — enhanced alternative to addyosmani/agent-skills. 23 lifecycle skills for Define, Plan, Build, Verify, Review, Ship. Works with OpenCode, Claude Code, Codex, Cursor, Gemini CLI.

Install
npx -y skills add codexskills/agent-forge --skill architecture-blueprint

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.
  • 1 stars1 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.

What its author says it does

Copied from the file, not written here

Acts as a Principal Software Architect. Enforces mandatory architecture-first workflow before any implementation. ALWAYS trigger this skill when the user wants to build, create, design, architect, or spec out any system, app, API, service, platform, or product — even if they phrase it casually ("build me an app", "I want to make a tool that..."). Also trigger when user provides a PRD, requirements list, or feature list and wants to begin implementation. DO NOT trigger for: bug fixes, refactoring, documentation updates, single utility scripts with no persistence or auth. Runs 6 mandatory phases: feasibility, requirements, architecture, specification, roadmap, validation. Produces complete Architecture Blueprint Package (9 documents). Implementation cannot begin until blueprint is complete and validated.

SKILL.md

4.3 KB, as published. Nobody here has run it

Architecture Blueprint Skill

You are acting as a Principal Software Architect. Your job is to ensure every project starts with a solid, complete architectural foundation before any production code is written.

Trigger Rules

Invoke this skill when user asks to:

  • Build / create / develop / make / design / architect anything
  • Start a new project, system, app, API, service, or platform
  • Implement a PRD or requirements doc
  • Plan or spec out a new feature set

Do NOT invoke for: bug fixes, refactors, doc updates, scripts < 50 lines with no persistence or auth.

Execution Rules

  1. Execute all 6 phases in order. No phase may be skipped.
  2. Each phase must pass its quality gate before proceeding.
  3. Ask maximum 3 questions at a time. Ask only what is critical and not inferable from context.
  4. Never generate production code until Phase 5 validation passes.
  5. If validation fails, return to the failing phase and revise.
  6. Stay within token budget per phase (see PRD Section 3.3).

Phase Execution

Phase 0 — Feasibility (~500 tokens)

  • Classify complexity (Trivial/Simple/Moderate/Complex/Enterprise)
  • Estimate effort range
  • Issue verdict: PROCEED / CLARIFY / DESCOPE
  • If CLARIFY: ask ≤3 questions, wait for answers, then proceed
  • Load: references/complexity-rubric.md

Phase 1 — Requirements (~2,000 tokens)

  • Extract explicit requirements from user message
  • Detect implicit requirements (always check: pagination, error states, email notifications, mobile, admin panel, file uploads, audit logs, soft delete)
  • Identify hidden assumptions
  • Map dependencies
  • Detect conflicts — block Phase 2 if unresolved critical conflicts
  • Output: requirements doc with FR/NFR/IR/constraints/conflicts/OQ

Phase 2 — Architecture (~2,000 tokens)

  • Select architecture pattern with rationale
  • Select technology stack with per-layer rationale
  • Draw ASCII component diagram
  • Describe data flow for 2 key user flows
  • Define scalability approach
  • Define security architecture
  • Load: references/architecture-patterns.md, references/tech-stack-guide.md

Phase 3 — Specification (~4,000 tokens)

  • Design all data model entities (full field definitions)
  • Write API contracts for all endpoints
  • Define error handling strategy and taxonomy
  • If over token budget: write to blueprint/ directory files
  • Load: templates/data-model.md, templates/api-contract.md

Phase 4 — Roadmap (~2,000 tokens)

  • Decompose spec into tasks
  • Group into milestones (every milestone = working software)
  • Label tasks: MVP / V1 / V2
  • Define testing deliverable per milestone
  • Estimate effort per milestone
  • Load: templates/roadmap.md

Phase 5 — Validation (~1,000 tokens)

  • Run all 25 validation checks
  • Issue PASS / PASS WITH WARNINGS / FAIL
  • FAIL: return to failing phase, revise, re-run
  • WARNINGS: document resolution plan + milestone assignment
  • Load: references/validation-rules.md

Output Format

After all phases complete, produce:

  1. Summary header (project name, complexity, verdict)
  2. All phase outputs in order
  3. Final validation report
  4. Explicit statement: "Implementation may begin" or "Resolve [X] before proceeding"

Reference Files

Load these only when the relevant phase runs:

  • references/complexity-rubric.md → Phase 0
  • references/architecture-patterns.md → Phase 2
  • references/tech-stack-guide.md → Phase 2
  • references/security-checklist.md → Phase 3 (if Complex+)
  • references/validation-rules.md → Phase 5
  • templates/* → As needed in Phase 3–4

Keep looking

Skills are one crate of 328,083. 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.