New: 98,000+ skills indexed from GitHub repos with 100+ stars · every skill safety-checkedBrowse top skillsTop skills
Esc to closeBrowse all skills
Submit a skillBrowse skills
Submit a skillBrowse skills

Agent skill

Architect Analyze

by tikalk in tikalk/adlc-team-skills

A skill your agent uses when validating generated or refined architecture artifacts, before feature development, during architecture review, or periodically to detect ADR↔AD drift, completeness…

MITAuto-check passedDevelopment

Install Architect Analyze

skills CLI
$ npx skills add tikalk/adlc-team-skills --skill architect-analyze -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install tikalk/adlc-team-skills architect-analyze --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/tikalk/adlc-team-skills.git skills-src && mkdir -p .claude/skills && cp -r skills-src/skills/architect/architect-analyze .claude/skills/architect-analyze && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
architect-analyze
GitHub stars
141
Token cost
~4.7k tokens
SKILL.md length
1,722 words
Files
1
Skills in repo
44
Repo updated
First seen
Licence
MIT

At a glance

A skill your agent uses when validating generated or refined architecture artifacts, before feature development, during architecture review, or periodically to detect ADR↔AD drift, completeness…

  • Works in 6 steps: Initialize Analysis Context → Determine Analysis Scope → Execute Detection Passes → …
  • Validating generated
  • SKILL.md covers What this skill does, When to use, Process and Next Steps, plus 1 more section
  • Instructions only: no scripts, shell commands, URLs or credentials in SKILL.md

What it does

Architect Analyze is an agent skill from tikalk/adlc-team-skills. Use when validating generated or refined architecture artifacts, before feature development, during architecture review, or periodically to detect ADR↔AD drift, completeness gaps, and quality issues.

Its SKILL.md is about 4.7k tokens, which your agent loads only when the skill is triggered. It is a single SKILL.md file with no bundled scripts.

It sits in Development, covering Architecture decision records and Software architecture. The repository describes itself as: Agent skills for the Agentic SDLC: team lifecycle (team-boot, team-learn, team-init, team-repair), software factory, evals, CDR lifecycle with confidence scoring, and… The licence is MIT.

When your agent uses it

  • Validating generated
  • Refined architecture artifacts
  • Before feature development
  • During architecture review

Example prompts

  • “/architect-analyze”

Workflow steps

6 steps, taken from the step headings in SKILL.md.

  1. Initialize Analysis Context
  2. Determine Analysis Scope
  3. Execute Detection Passes
  4. Severity Assignment
  5. Generate Analysis Report
  6. Offer Remediation

What it can do on your machine

Read from SKILL.md and the folder at commit 4c4ad44. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    No scripts in the folder and no shell commands in SKILL.md (its code samples are markdown).

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    No URLs in SKILL.md.

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Architect Analyze loads about 4.7k tokens when it runs. Until then it costs about 54 tokens; SKILL.md has 1,722 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~54
When it runs · the whole SKILL.md, loaded when a task matches
~4.7k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from tikalk/adlc-team-skills at commit 4c4ad44, republished under its MIT licence (© tikalk). 1,722 words, ~4,691 tokens.

Download SKILL.mdSave it as .claude/skills/architect-analyze/SKILL.md (or your agent's skills folder).
name
architect-analyze
description
Use when validating generated or refined architecture artifacts, before feature development, during architecture review, or periodically to detect ADR↔AD drift, completeness gaps, and quality issues.
disable-model-invocation
true

architect-analyze

What this skill does

Performs a read-only architecture consistency analysis between ADRs (Architecture Decision Records) and AD (Architecture Description). It identifies discrepancies, quality issues, and gaps without modifying any files.

Key analysis dimensions:

  1. ADR Quality — Completeness, clarity, and standards compliance
  2. ADR to AD Consistency — Bidirectional drift detection
  3. Internal Consistency — Cross-artifact coherence
  4. Staleness Detection — Outdated references and placeholders

This skill validates architecture artifacts for consistency, completeness, and quality.

When to use

  • After /architect-implement — Validate generated AD.md
  • After /architect-clarify — Verify ADR refinements
  • Before feature development — Ensure architecture is solid
  • During architecture review — Quality gate for architecture docs
  • Periodically — Detect drift as the codebase evolves

Do not use when no architecture artifacts exist; use /architect-init or /architect-specify first. Do not use to create architecture — this is analysis-only.

Process

User Input

Consider the user input before proceeding (if not empty):

text
$ARGUMENTS

Examples:

  • "system" — Focus on root-level AD.md and adr/ directory only
  • "feature auth" — Focus on specific feature architecture
  • "adrs" — Focus on ADR quality and inter-ADR consistency
  • "views" — Focus on AD.md view completeness and internal consistency
  • Empty input — Full analysis of all architecture artifacts
Goal

Perform read-only architecture consistency analysis. Identify discrepancies, quality issues, and gaps without modifying any files.

Operating Constraints

STRICTLY READ-ONLY: Do not modify any files. Output a structured analysis report. Offer remediation suggestions (user must explicitly approve before any follow-up editing commands would be invoked manually).

Constitution Authority: The project constitution (memory/constitution.md) is non-negotiable within this analysis scope. Constitution conflicts are automatically CRITICAL.

Role & Context

Act as an Architecture Analyst validating architecture documentation quality:

  • Validate ADR completeness against MADR standards
  • Detect drift between ADRs and AD.md
  • Identify internal inconsistencies across artifacts
  • Flag staleness and quality issues

Architecture document hierarchy:

DocumentLocationPurpose
AD.mdProject rootFull Architecture Description (Rozanski & Woods)
adr/{REPO_ROOT}/docs/adlc/memory/ (legacy .adlc/memory/ fallback)System-level ADRs (individual files)
constitution.md{REPO_ROOT}/docs/adlc/memory/ (legacy .adlc/memory/ fallback)Governance principles and constraints
Outline
  1. Initialize Analysis Context — Load architecture artifacts
  2. Determine Analysis Scope — System, feature, or full
  3. Execute Detection Passes — A through G
  4. Assign Severities — CRITICAL/HIGH/MEDIUM/LOW
  5. Generate Report — Structured markdown analysis
  6. Provide Next Actions — Remediation suggestions
Phase 1: Initialize Analysis Context

Objective: Load all architecture artifacts for analysis

  1. Run Setup Script:

    • Execute {REPO_ROOT}/.agents/skills/architect-clarify/scripts/bash/setup-architect.sh (Requires the architect-clarify skill: adlc-cli skills add tikalk/adlc-team-skills --skill architect-clarify). from repo root
    • Parse JSON for file paths and existence status

  2. Load System-Level Artifacts:

    • Read AD.md (project root) if exists
    • Read ADRs from all locations (priority order):
      1. {REPO_ROOT}/docs/adlc/memory/adr/adr.md (canonical — Accepted ADRs; legacy {REPO_ROOT}/.adlc/memory/adr/adr.md fallback per ADR-401 dual-read)
      2. {REPO_ROOT}/.adlc/drafts/adr/ (working copy — Proposed/Discovered, individual file format)
    • Read {REPO_ROOT}/docs/adlc/memory/constitution.md (legacy {REPO_ROOT}/.adlc/memory/constitution.md fallback) if either exists

  3. Load Feature-Level Artifacts (if analyzing features):

    • Scan specs/*/AD.md for feature architectures
    • Scan specs/*/adr/ADR-*.md for feature ADRs

  4. Build Artifact Inventory:

    ArtifactPathStatus
    System ADAD.mdFound/Missing
    System ADRs (canonical){REPO_ROOT}/docs/adlc/memory/adr/adr.md (legacy .adlc/memory/adr/adr.md fallback)Found/Missing
    System ADRs (drafts){REPO_ROOT}/.adlc/drafts/adr/Found/Missing
    Constitution{REPO_ROOT}/docs/adlc/memory/constitution.md (legacy .adlc/memory/constitution.md fallback)Found/Missing
    Feature ADsspecs/*/AD.mdCount: N
    Feature ADRsspecs/*/adr/Count: N
Phase 2: Determine Analysis Scope

Objective: Focus analysis based on user input

User InputScopeArtifacts Analyzed
(empty)FullAll system artifacts
"system"System onlyAD.md, system ADR locations
"adrs"ADR qualityAll ADR files
"views"AD completenessAD.md
Phase 3: Execute Detection Passes

Focus on high-signal findings. Limit to 50 findings total; aggregate remainder in overflow summary.

Pass A: ADR Quality Analysis

Objective: Validate each ADR against MADR standards

Quality Dimensions:

DimensionCheckSeverity if Missing
ContextProblem clearly stated, forces documentedMEDIUM
DecisionActionable, testable decision statementHIGH
Positive ConsequencesBenefits documentedMEDIUM
Negative ConsequencesTrade-offs acknowledgedHIGH
RisksIdentified with mitigationsMEDIUM
AlternativesAt least 2 options with neutral trade-offsHIGH
StatusValid status (Proposed/Accepted/Deprecated/Superseded/Discovered)LOW
Constitution AlignmentMUST principles complied withCRITICAL

ADR Quality Checklist:

For each ADR, verify:

  • Clear context explaining the problem/opportunity
  • Explicit, actionable decision statement
  • Positive AND negative consequences documented
  • Common Alternatives with neutral trade-offs (not "Rejected because")
  • Risks identified with mitigation strategies
  • Valid status value
  • No conflicts with constitution MUST principles
Pass B: Inter-ADR Consistency

Objective: Detect conflicts and inconsistencies between ADRs

Checks:

  1. Conflicting Decisions:

    • ADRs that contradict each other (e.g., one chooses PostgreSQL, another assumes MongoDB)
    • Technology stack incoherence

  2. Missing Dependencies:

    • ADRs that should reference each other but don't
    • Implicit assumptions about other decisions

  3. Terminology Drift:

    • Same concept named differently across ADRs
    • Inconsistent component naming

  4. Technology Stack Coherence:

    • Frontend/backend/infrastructure choices align
    • No conflicting framework decisions
Pass C: ADR to AD Drift (Forward Sync)

Objective: Detect ADR decisions not reflected in AD.md

Checks:

ADR ElementExpected in AD.mdView/Section
System architecture styleContext View3.1
Database choiceInformation View3.3
API styleFunctional View3.2
Authentication approachSecurity Perspective4.1
Deployment platformDeployment View3.6
CI/CD approachDevelopment View3.5
Scaling strategyPerformance Perspective4.2
Caching strategyInformation View3.3

Detection Logic:

For each ADR:

  1. Identify the ADR's primary view impact (use mapping table above)
  2. Search AD.md for reflection of that decision
  3. Flag if decision is absent or contradicted
Pass D: AD to ADR Drift (Backward Sync)

Objective: Detect AD.md elements without supporting ADRs

Checks:

  1. Components Without ADRs:

    • Major components shown in Functional View without decision rationale
    • External dependencies in Context View without ADR justification

  2. Patterns Without Rationale:

    • Architectural patterns described but not explained via ADR
    • Technology choices embedded in views without supporting decision

  3. Infrastructure Decisions:

    • Deployment topology without infrastructure ADR
    • Scaling approach without performance ADR
Show full SKILL.md (828 more words)Show less
Pass E: AD Internal Consistency

Objective: Validate AD.md coherence across views

Checks:

  1. Cross-View Consistency:

    • Same components named identically across all views
    • Data entities in Information View match Functional View references
    • Deployment nodes consistent with Functional components

  2. Diagram-Text Alignment:

    • Mermaid diagrams match prose descriptions
    • No components in diagrams missing from text
    • No components in text missing from diagrams

  3. View Completeness:

    • Required sections present (Introduction, Stakeholders, Views, Perspectives)
    • Core views included (Context, Functional, Information, Development, Deployment)
    • Perspectives addressed (Security, Performance)

  4. Diagram Syntax Validation:

    • Mermaid syntax valid (no broken diagrams)
    • Consistent styling across diagrams

  5. View File Consistency (DAG State Validation):

    • Check if .adlc/architect/state.json exists and reports views as "completed"
    • Check if docs/adlc/architect/views/ (legacy .adlc/architect/views/ fallback) directory exists
    • Verify that for each "completed" view in state.json, a corresponding file exists on disk
    • Flag as HIGH severity if:
      • state.json reports views "completed" but views/ directory is empty
      • View files exist but are under 20 lines (placeholder/skeleton content)
      • View files cannot be read (corrupted/missing permissions)
    • Report format:
      DAG State Inconsistency Detected:
- State reports: [N] views completed
- Files on disk: [M] view files found
- Missing files: [list of missing views]
- Recommendation: Regenerate views or reset state.json

  6. Technology Neutrality (Functional View):

    • Scan Functional View (§3.2) for product/vendor names in element descriptions and Mermaid diagrams
    • Architectural roles (acceptable): Database, Object Storage, Cache, Message Queue, AI Gateway, Workflow Runtime, App Shell, API Gateway, Authentication Service, etc.
    • Product names (flag as MEDIUM): PostgreSQL, Neon, Vercel, Next.js, Redis, MongoDB, AWS, Azure, S3, etc.
    • Severity: MEDIUM — Not blocking but indicates abstraction violation
    • Note: ADR Traceability sections may reference products (that's acceptable); only flag element descriptions and diagram labels

  7. Functional-Development Mapping:

    • Verify Development View (§3.5) contains a Technology Stack Mapping table (§3.5.2)
    • Check that every element in Functional View's element table (§3.2.1) has at least one corresponding entry in the mapping table
    • N:1 mappings (multiple functional elements → one technology) are acceptable
    • Severity: MEDIUM if elements are missing; LOW if mapping table is absent
    • Cross-check: Technology Architecture diagram (§3.5.3) should mirror Functional View diagram (§3.2.2) structure
Pass F: Staleness Detection

Objective: Identify outdated references and placeholders

Checks:

  1. Deprecated ADRs Still Referenced:

    • AD.md references ADRs with status "Deprecated"
    • Superseded decisions still implemented

  2. Placeholder Detection:

    • [TODO], [TBD], [PLACEHOLDER] markers
    • [SYSTEM_NAME], [STAKEHOLDER_*] unfilled
    • ???, ..., <placeholder> patterns

  3. Date Inconsistencies:

    • ADR dates significantly older than AD last-updated
    • Feature architecture out of sync with system architecture

  4. Orphaned References:

    • ADR IDs mentioned but ADR doesn't exist
    • Component names referenced but not defined
Pass G: Feature-System Alignment (if feature architecture exists)

Objective: Validate feature architecture fits within system boundaries

Checks:

  1. Feature ADR Alignment:

    • Feature ADRs marked "Aligns with ADR-XXX" reference valid system ADRs
    • No VIOLATION flags without documented justification
    • Feature decisions consistent with system constraints

  2. Boundary Compliance:

    • Feature components fit within system Functional View structure
    • Feature data entities align with system Information View
    • Feature doesn't exceed system scope (Context View)

  3. Integration Points:

    • Feature-to-system interfaces documented
    • Data flow across feature boundary consistent
Phase 4: Severity Assignment

Severity Criteria:

SeverityCriteriaExamples
CRITICALConstitution violation, security/data integrity gap, missing core ADRADR violates MUST principle, major component undocumented
HIGHADR to AD drift affecting implementation, conflicting ADRs, missing alternativesDatabase choice in ADR but wrong DB in AD, two ADRs conflict
MEDIUMIncomplete consequences, staleness, terminology drift, missing optional viewsADR lacks negative consequences, TODO placeholders
LOWStyle improvements, minor documentation gaps, optional detailsInconsistent formatting, minor wording issues
Phase 5: Generate Analysis Report

Output Format:

markdown
## Architecture Analysis Report

### Analysis Summary

| Attribute | Value |
|-----------|-------|
| **Mode** | [Full/System/Feature/ADRs/Views] |
| **Scope** | [Description of what was analyzed] |
| **Files Analyzed** | [List of files] |
| **Analysis Date** | [Current date] |

### Findings

| ID | Pass | Severity | Location | Summary | Recommendation |
|----|------|----------|----------|---------|----------------|
| A1 | ADR Quality | MEDIUM | ADR-003 | Missing negative consequences | Add trade-offs section |
| B1 | Inter-ADR | HIGH | ADR-002, ADR-005 | Conflicting database choices | Resolve PostgreSQL vs MongoDB conflict |
| C1 | ADR->AD Drift | HIGH | ADR-005 | Caching decision not in Information View | Update AD.md 3.3 |
| D1 | AD->ADR Drift | HIGH | AD.md:3.2 | Redis component has no ADR | Create ADR for cache choice |
| E1 | AD Consistency | MEDIUM | AD.md:3.2/3.6 | Component naming mismatch | Standardize "AuthService" naming |
| F1 | Staleness | LOW | AD.md:3.1 | [SYSTEM_NAME] placeholder | Fill in system name |
| G1 | Feature Align | HIGH | specs/auth/adr.md | VIOLATION flag unresolved | Document override justification |

### Coverage Metrics

| Metric | System | Feature: auth | Feature: payments |
|--------|--------|---------------|-------------------|
| ADR Count | 13 | 3 | 2 |
| AD Views Complete | 5/7 | 3/5 | 3/5 |
| ADR->AD Coverage | 85% | 100% | 67% |
| AD->ADR Coverage | 92% | 100% | 100% |
| Quality Score | 78% | 85% | 72% |

### Constitution Alignment

| Status | Count | Details |
|--------|-------|---------|
| Compliant | [N] | ADRs following MUST principles |
| Violations | [N] | ADRs violating MUST principles (CRITICAL) |
| Deviations | [N] | Justified SHOULD principle deviations |

### Issue Distribution

| Severity | Count |
|----------|-------|
| CRITICAL | [N] |
| HIGH | [N] |
| MEDIUM | [N] |
| LOW | [N] |

### Next Actions

Based on findings, recommended actions:

**If CRITICAL issues exist:**
- **Immediate**: Resolve constitution violations before proceeding
- Command: `/architect-clarify` to address ADR compliance

**If HIGH ADR quality issues:**
- **Refine**: Address missing alternatives and consequences
- Command: `/architect-clarify` to improve ADR quality

**If ADR->AD drift detected:**
- **Sync AD**: Update AD.md to reflect ADR decisions
- Command: `/architect-implement` to regenerate views

**If AD->ADR drift detected:**
- **Document**: Create missing ADRs for undocumented decisions
- Command: `/architect-specify` or `/architect-init` to add ADRs

**If feature alignment issues:**
- **Align**: Resolve feature-system boundary violations
- Command: Run `/architect-specify` or `/architect-init` to create missing ADRs
Phase 6: Offer Remediation

After presenting the report, ask:

"Would you like me to suggest specific remediation steps for the top [N] issues? I can provide detailed guidance for each finding, though I will not make any changes automatically."

Key Rules
Analysis Integrity
  • NEVER modify files — this is read-only analysis
  • NEVER hallucinate missing content — report absences accurately
  • Prioritize constitution violations — these are always CRITICAL
  • Use evidence-based findings — cite specific locations and content
Consistency Standards
  • Cross-reference everything — validate bidirectionally (ADR to AD)
  • Check all levels — system and feature architecture must align
  • Validate terminology — same concepts must use same names
  • Verify diagrams — Mermaid syntax must be valid
Reporting Standards
  • Limit to 50 findings — aggregate overflow in summary
  • Include location — always cite file:line or section
  • Provide actionable recommendations — each finding gets a fix suggestion
  • Calculate coverage metrics — quantify completeness

Next Steps

If issues are found:

  • Run /architect-clarify to refine ADRs (quality issues, missing consequences/alternatives, constitution violations).
  • Run /architect-implement to regenerate AD.md when ADR-to-AD drift is detected.

For missing ADRs or feature boundary issues, use /architect-specify or /architect-init as appropriate.

Verification

Concrete outputs of this skill:

  • Architecture Analysis Report in structured markdown, including:
    • Analysis Summary (mode, scope, files analyzed, analysis date)
    • Findings table with ID, pass, severity, location, summary, and recommendation
    • Coverage Metrics (ADR count, AD views complete, ADR→AD coverage, AD→ADR coverage, quality score)
    • Constitution Alignment summary (compliant, violations, deviations)
    • Issue Distribution by severity (CRITICAL, HIGH, MEDIUM, LOW)
    • Next Actions tailored to finding types
  • No files modified — analysis is strictly read-only.
  • User-approved remediation guidance offered after the report.

© tikalk, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

Just SKILL.md in skills/architect/architect-analyze of tikalk/adlc-team-skills.

Open the folder on GitHubat commit 4c4ad44

Compare with similar skills

Architect Analyze next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Architect Analyze compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Architect Analyze this skilltikalk/adlc-team-skills141—~4.7kAutomated safety check: PassMIT
Create Vibe Featuremistralai/mistral-vibe5.1k—~1.2kAutomated safety check: PassApache-2.0
Architecture Decisions and ADRsfirst-fluke/oh-my-agent1.3k—~2.6kAutomated safety check: PassMIT
System Architecture DesignerJeffallan/claude-skills12k—~1.2kAutomated safety check: PassMIT
Light System DesignLight0305/Light-skills640—~3.6kAutomated safety check: PassMIT
Architecture DesignerAratKruglik/claude-laravel1551 repos~895Automated safety check: PassNone

Similar skills

  • Create Vibe Feature

    mistralai/mistral-vibe

    Official

    Guides feature work in the Mistral Vibe Python CLI so each change lands in the right module and matches the project's architecture decision records.

    5.1k GitHub stars~1.2k tokensUpdated 2 days ago
    DevelopmentAuto-check passed

  • Architecture Decisions and ADRs

    first-fluke/oh-my-agent

    Evaluates system boundaries and tradeoffs and writes architecture recommendations, option comparisons or ADRs, with a Mermaid diagram when structure changes.

    1.3k GitHub stars~2.6k tokensUpdated today
    DevelopmentAuto-check passed

  • System Architecture Designer

    Jeffallan/claude-skills

    Guides system architecture design end to end: gathering requirements, matching them to a pattern, documenting trade-offs with ADRs, and reviewing.

    12k GitHub stars~1.2k tokensUpdated 6 days ago
    DevelopmentAuto-check passed

  • Light System Design

    Light0305/Light-skills

    Evidence-based workflow for designing or modernizing a software system: current-state inventory, options, API and schema contracts, migration plans, ADRs and verification.

    640 GitHub stars~3.6k tokensUpdated 3 mo ago
    DevelopmentAuto-check passed

  • Architecture Designer

    AratKruglik/claude-laravel

    A skill your agent uses when designing new system architecture, reviewing existing designs, or making architectural decisions.

    155 GitHub starsUsed in 1 repo~895 tokens
    DevelopmentAuto-check passed

  • Architecture Decision Record Writer

    dralgorhythm/claude-agentic-framework

    Writes Architecture Decision Records with title, status, context, decision, rationale and consequences for significant technical choices, kept short and numbered.

    125 GitHub stars~529 tokensUpdated 2 mo ago
    DevelopmentAuto-check passed

More from tikalk/adlc-team-skills

All 44 skills in this repo

  • Team Boot

    tikalk/adlc-team-skills

    A skill your agent uses when a session starts or resumes after compaction (auto via the sessionstart and sessioncompact event hooks) and the team AI directives context — constitution, CDR index…

    141 GitHub stars~2.2k tokensUpdated yesterday
    Auto-check passed

  • Architect Clarify

    tikalk/adlc-team-skills

    A skill your agent uses when ADRs need review, gaps need filling, or ADR status must be approved as Accepted before architecture generation.

    141 GitHub stars~4.7k tokensUpdated yesterday
    Auto-check passed

  • Change Clarify

    tikalk/adlc-team-skills

    A skill your agent uses when reviewing, accepting, rejecting, or deferring ChDRs mined by change-init, validating inferred decisions against their git and issue evidence before promotion to project…

    141 GitHub stars~2.9k tokensUpdated yesterday
    Auto-check passed

  • Change Init

    tikalk/adlc-team-skills

    A skill your agent uses when you want guided mining of git history, structured change-story clustering, or comprehensive rationale recovery before documenting.

    141 GitHub stars~3.5k tokensUpdated yesterday
    Auto-check passed

  • Change Publish

    tikalk/adlc-team-skills

    A skill your agent uses when accepted ChDRs are ready for promotion from drafts to project memory at docs/adlc/memory/chdr/ and the boot-facing chdr.md index needs regenerating.

    141 GitHub stars~2k tokensUpdated yesterday
    Auto-check passed

  • Evals Analyze

    tikalk/adlc-team-skills

    A skill your agent uses when evaluation results need triage and loop-closing — spec failures route to deterministic checks or context rules, generalization failures to the evaluator backlog.

    141 GitHub stars~1.2k tokensUpdated yesterday
    Auto-check passed

Categories

Questions about Architect Analyze

What does Architect Analyze do?

A skill your agent uses when validating generated or refined architecture artifacts, before feature development, during architecture review, or periodically to detect ADR↔AD drift, completeness…. Architect Analyze is an agent skill from tikalk/adlc-team-skills. Use when validating generated or refined architecture artifacts, before feature development, during architecture review, or periodically to detect ADR↔AD drift, completeness gaps, and quality issues.

When should I use Architect Analyze?

Architect Analyze fits situations like: validating generated; refined architecture artifacts; before feature development; during architecture review.

How do I install Architect Analyze in Claude Code?

Run `npx skills add tikalk/adlc-team-skills --skill architect-analyze -a claude-code`. Or copy the skill folder (skills/architect/architect-analyze in tikalk/adlc-team-skills) into .claude/skills/architect-analyze in your project. Claude Code loads it when a task matches its description.

How do I install Architect Analyze in Codex?

Run `npx skills add tikalk/adlc-team-skills --skill architect-analyze -a codex`. Or copy the skill folder (skills/architect/architect-analyze in tikalk/adlc-team-skills) into .agents/skills/architect-analyze in your project. Codex loads it when a task matches its description.

Can I use Architect Analyze in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add tikalk/adlc-team-skills --skill architect-analyze -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/architect-analyze, .gemini/skills/architect-analyze, .github/skills/architect-analyze and .opencode/skills/architect-analyze in your project.

What does Architect Analyze need to run?

SKILL.md names no scripts, command-line tools or credentials: Architect Analyze is instructions for the agent only.

Does Architect Analyze access the network?

SKILL.md contains no URLs. Any network use would come from the scripts or tools the agent runs. This is read from the text; nothing was executed.

Is Architect Analyze safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does Architect Analyze use?

Architect Analyze is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Architect Analyze use?

About 4.7k tokens (SKILL.md is roughly 19k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.

What are the alternatives to Architect Analyze?

Skills that share tags, products or a category with Architect Analyze: Create Vibe Feature (mistralai/mistral-vibe, 5.1k stars), Architecture Decisions and ADRs (first-fluke/oh-my-agent, 1.3k stars), System Architecture Designer (Jeffallan/claude-skills, 12k stars) and Light System Design (Light0305/Light-skills, 640 stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Architect Analyze?

tikalk (a GitHub organization) maintains it in tikalk/adlc-team-skills, which has 141 GitHub stars. The repository holds 44 skills in this directory. The repository was last updated on October 8, 2026.

Source: tikalk/adlc-team-skills on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.