⏳ This skill is pending AI review.

Scores will appear once the review pipeline completes.

version unknown

ln-21-system-design-baseline-builder

levnikolaevich@levnikolaevich⭐ 595 stars· last commit 4d ago· 1 open issues

Defines measurable architecture drivers and constraints before system design; edits architecture docs only.

Choose how to use this skill

You do not need every option. Choose the path your AI client supports. The stable page stays the same; versioned files are immutable.

1. Native installer

This listing has no registered native installer command. Use the complete package or source fallback below, depending on what your client supports.

Do not guess an installer command or replace an existing version without reviewing the diff.

2. Complete package recommended

Download the ZIP when available. It includes SKILL.md plus the references, security notes and version metadata.

No complete ProSkills package is published for this listing yet.

3. Prompt-only

Copy the prompt above when the agent can read the stable page or when you want to adopt the workflow without installing a skill.

Need only the instruction file?

Download SKILL.md only if your client requires a single file. The complete ZIP is safer for a full installation because it preserves the references and release context.

No path installs or executes anything by itself. Your agent still needs access to the project files. Before updating, compare the installed version and review the diff.

—/10

// RATINGS

⭐GitHub Stars
⭐⭐⭐⭐ 595 on GitHubGitHub ↗

Popular

🟢ProSkills Score
—
📍

Not yet listed on ClawHub or SkillsMP

// README

Claude-Codex Skills

Open-source standalone agent skills, distributed as plugins for Claude Code and OpenAI Codex, help turn product ideas, code fixes, architecture reviews and deployments into scoped work with a verifiable result. Each workflow defines what to check, what it may change, and how to report evidence and remaining gaps.

Project page · Install · Full catalog

Choose a route

Choose by the result you need. Each skill works independently.

Your taskPluginResult
Is this idea worth building?product-discovery-suiteOpportunity assessment, requirements, or interaction design.
How should this system change?architecture-suiteSystem map, design decision, or migration plan.
Is this plan ready to implement?delivery-planning-suiteReviewed plan, ordered work, and test strategy.
Fix, upgrade, simplify, or speed up this code.implementation-suiteScoped change with behavior and benefit checks.
Set up lint, type or architecture checks that enforce project rules.implementation-suiteVerified quality gates, with project compliance reported separately.
What could go wrong with this delivery or codebase?quality-assurance-suiteEvidence-backed findings or scoped acceptance tests.
Get this change published or deployed.delivery-suiteAuthorized publication or deployment, verified at its destination.
Why did this fail, or did the feature help?operations-suiteIncident diagnosis or product outcome assessment.
Can I trust the instructions in this skill?skill-maintenance-suiteSkill boundaries, consistency, and distribution review.
Prepare Docker containers, configuration, access control or recovery.engineering-foundation-suiteNative technical contracts and verified changes.

Install

For a feature or fix, start with implementation-suite. Replace it with another plugin from Choose a route for a different task.

Claude Code:

/plugin marketplace add levnikolaevich/claude-code-skills
/plugin install implementation-suite@levnikolaevich-skills-marketplace
/reload-plugins

Codex:

codex plugin marketplace add levnikolaevich/claude-code-skills
codex plugin add implementation-suite@levnikolaevich-skills-marketplace

Invoke a skill by its full name: /implementation-suite:ln-41-surgical-change-implementer in Claude Code or $ln-41-surgical-change-implementer in Codex, followed by your task. For example: “Fix the total calculation when an item has a discount. Preserve the current rounding rules.”

For personal defaults shared by Claude Code and Codex, use the optional user instructions template and connection guide. Personalize and merge it into your existing configuration; plugin installation does not change global instructions.

Lifecycle and plugins

Product Discovery Suite

Decide what is worth building, who it serves, and what a useful first version must do.

IndexSkillPurpose
11Opportunity EvaluatorEvaluates new product opportunities through demand, channels and economics before committing to build.
12Product Requirements BuilderDefines product requirements, business rules and acceptance criteria for a committed intent; edits product docs only.
13Interaction Design BuilderDesigns user flows, interaction states and mockups for a defined product scope; does not implement UI code.

Architecture Suite

Understand the system you have and choose changes with clear boundaries, tradeoffs, and recovery paths.

IndexSkillPurpose
21System Design Baseline BuilderDefines measurable architecture drivers and constraints before system design; edits architecture docs only.
22Current Architecture DocumenterDocuments current architecture from implementation evidence; does not propose a target or audit fitness.
23System Design Proposal BuilderDesigns target system boundaries, contracts and tradeoffs from requirements; does not plan tasks or implement.
24Architecture Decision RecorderRecords one architecture decision with alternatives, consequences and status; does not design the whole system.
25Architecture Diagram BuilderCreates evidence-backed current or target architecture diagrams; not UI design.
26Architecture Migration PlannerPlans architecture migrations with compatibility, data safety, rollout and recovery; does not execute them.

Delivery Planning Suite

Find missing decisions and risky dependencies before they become implementation rework.

IndexSkillPurpose
31Delivery Plan BuilderBuilds dependency-ordered delivery plans from requirements and repository evidence; read-only.
32Test Strategy PlannerPlans risk-based test portfolios and acceptance evidence; does not write or execute tests.
33Plan ReviewerReviews a concrete implementation plan for missing decisions, feasibility and risk before execution; read-only.

Implementation Suite

Fix the cause, reuse what already works, and keep changes focused on a verified outcome.

IndexSkillPurpose
41Surgical Change ImplementerImplements one scoped product feature or fix using existing contracts; not upgrades, performance tuning or establishing cross-cutting technical foundations.
42Dependency UpgraderUpgrades dependencies in reversible batches with version-specific compatibility and regression checks.
43Code ModernizerModernizes a bounded capability to reduce demonstrated maintenance cost; not routine upgrades or performance tuning.
44Performance OptimizerProfiles and improves a measured performance bottleneck; retains only verified improvements.
45Benchmark ComparatorCompares tools or implementations through controlled benchmarks and independent correctness checks.
46Quality Gate EngineerConfigures and verifies lint, type, architecture and other engineering checks; not product cleanup, policy invention or deployment redesign.

Quality Assurance Suite

Find gaps that could break a release, mislead a maintainer, or make a passing test meaningless.

IndexSkillPurpose
51Acceptance Test BuilderBuilds, upda

// HOW IT'S BUILT

// FILES

2 files shipped with this skill. Inline text is the catalog copy. The upstream link is the source repository.

  • plugins/architecture-suite/skills/ln-21-system-design-baseline-builder/SKILL.md7.8 KBupstream ↗
    ---
    name: ln-21-system-design-baseline-builder
    description: "Defines measurable architecture drivers and constraints before system design; edits architecture docs only."
    ---
    
    # System Design Baseline Builder
    
    **Goal:** Create or update one durable source of truth for the project's architecture-driving requirements and constraints. Change only the approved architecture document; do not design the solution, review a plan, audit implementation, edit product code, or invent missing targets.
    
    **Execution contract:** The checklist defines completion. Track each item internally as `PENDING`, `PROVEN` with evidence, `CLEARED` with evidence its condition is absent, or `UNPROVEN` with a gap; reading, delegation, tool failure, a zero exit status, or a self-reported success is not proof; only the observed outcome is. Reconcile after each section. Before returning, resolve all `PENDING`, count only `PROVEN` and `CLEARED`, and apply verdict and approval rules to every gap.
    Preserve intent, scope, and existing authorization. Continue authorized work; ask only for consequential unresolved choices or required external approval. When no one can answer during the run, state the exact question and apply the skill's verdict for the remaining gap instead of waiting or guessing. Scale depth to material risk without skipping checks. Preserve dependency and safety order; otherwise choose an appropriate verification method.
    Accept equivalent user or repository evidence; no other skill, named artifact, or complete lifecycle is required. Preserve source requirement and decision IDs. Bind reused evidence to relevant source versions, dirty changes, configuration, and environment; invalidate only affected claims.
    On continuation, reconcile task, authorization, current state, and unresolved evidence. For long work, return a compact continuation record or update an already authorized artifact; read-only skills do not persist it. Distinguish artifact readiness, verified behavior, and external-action authority.
    Prepare authorized work before required approval. If blocked by an instruction, cite its exact source and unresolved boundary; do not invent approval gates from caution.
    
    
    ## Tool Routing
    
    | Need | Preferred capability | Fallback |
    |---|---|---|
    | Repository rules and document conventions | Native file reads plus focused search | User-provided convention with an explicit limitation |
    | Existing requirements and architecture artifacts | Narrow repository search and direct reads | Conversation evidence marked with its source |
    | Current workload or service evidence | Metrics, dashboards, logs, manifests, or checked-in reports | Mark `UNKNOWN`; never manufacture production numbers |
    | Current external limits or standards | Official documentation or specifications | Mark the claim `UNVERIFIED` |
    | Document mutation | Minimal patch to the approved Markdown artifact | Return `BLOCKED` if no safe writable path is authorized |
    
    Use external research only when a time-sensitive fact changes a constraint. Do not browse for values that must come from product owners, operators, the repository, or measured workload.
    
    ## Artifact Rules
    
    - Prefer an existing unambiguous architecture-requirements document.
    - Otherwise use `docs/architecture/system-design-baseline.md`.
    - Read before writing, preserve unrelated content, and update facts in place instead of creating parallel truth.
    - Classify applicability separately as `APPLICABLE` or `NOT_APPLICABLE`, with evidence for exclusions.
    - Rank each applicable item as `DRIVER`, `SUPPORTING`, or `INFORMATIONAL`.
    - Classify evidence separately as `CONFIRMED`, `ASSUMED`, or `UNKNOWN`.
    - Separate observed current values, required targets, hard limits, and future evolution triggers.
    - Express quality attributes through observable scenarios and response measures; record undecided targets as missing decisions rather than inventing numbers.
    - Treat the baseline as versioned project knowledge, not an immutable promise.
    
    ## Checklist
    
    ### 1. Establish Scope and Destination
    
    - [ ] Resolve the project, business outcome, intended readers, approved documentation scope, and language.
    - [ ] Read applicable repository instructions and inspect Git state so unrelated changes remain untouched.
    - [ ] Search for existing requirement, architecture, SLO, recovery, security, cost, and ownership documents.
    - [ ] Select one canonical artifact: reuse a clear equivalent or choose the default path; explain why no duplicate will be created.
    - [ ] Return `BLOCKED` if the destination is ambiguous and choosing one could split project truth.
    
    ### 2. Build the Evidence Ledger
    
    - [ ] Collect business goals, actors, journeys, scope, non-goals, and decision horizon with their sources and confidence for the driver analysis; do not create a second context inventory.
    - [ ] Record sources for current workload, data volume, service behavior, platform limits, and existing commitments.
    - [ ] Separate repository facts from stakeholder choices and estimates.
    - [ ] Detect contradictions between documents, code, configuration, and stated requirements; preserve both claims until resolved.
    - [ ] Ask only for choices whose absence materially changes architecture; mark all other gaps `UNKNOWN`.
    
    ### 3. Define and Prioritize Architecture Drivers
    
    - [ ] **Business and scope:** Record actors, critical journeys, business horizon, scope, non-goals, and externally committed outcomes.
    - [ ] **Demand and data scale:** Record current and target users, rates, concurrency, payloads, growth, retention, and forecast horizon where relevant.
    - [ ] **User-observable service quality:** Define SLIs and SLOs for availability, latency, throughput, error rate, correctness, or freshness with measurement windows.
    - [ ] **Data semantics and recovery:** Define consistency, ordering, idempotency, reconciliation, durability, backup, RTO, RPO, and acceptable data loss at affected boundaries.
    - [ ] **Security, privacy, and compliance:** Define trust boundaries, data classification, residency, access, audit, and destructive-action constraints.
    - [ ] **Operations and economics:** Define ownership, operational capacity, cost envelope, supported regions, delivery cadence, and platform or vendor constraints.
    - [ ] **Evolution:** Record thresholds, business events, or evidence that justify revisiting an assumption, target, or deferred capability.
    - [ ] Separate applicability, criticality, and evidence status; do not use `UNKNOWN` to mean unimportant or `NOT_APPLICABLE`.
    - [ ] Prioritize the few scenarios most likely to shape architecture and express each as source/stimulus/environment/artifact/response/measure.
    
    ### 4. Write the Baseline
    
    - [ ] Create or update the artifact with: identity and status; business context; scope and non-goals; critical scenarios; workload and data; quality targets; recovery; consistency; security; cost and operations; constraints; assumptions and unknowns; review triggers.
    - [ ] Give material parameters their theme, applicability, criticality, evidence status, value/range, source, owner, as-of date, and review trigger. State shared metadata once with explicit inheritance; use `UNKNOWN` for missing ownership or values.
    - [ ] Keep calculations reproducible and label estimates separately from observed measurements.
    - [ ] Link shared architecture artifacts only by repository path or document title; never require a particular workflow or tool.
    - [ ] Preserve historical context needed to understand changed requirements instead of silently rewriting prior commitments.
    
    ### 5. Validate and Report
    
    - [ ] Re-read the written artifact and verify that no unknown was converted into a confident fact.
    - [ ] Check that targets are measurable, internally consistent, and proportionate to the evidenced business horizon.
    - [ ] Check that every architecture-critical gap has an owner or exact next evidence action.
    - [ ] Link architecture drivers to their source product requirements; preserve the product source as owner of function
  • README.mdupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

Plain-text copy, no login: /skill-bundles/levnikolaevich-claude-code-skills-plugins-architecture-suite-skills-ln-21-system.md

// REPO STATS

595 stars
1 open issues
Last commit: 4d ago