Coding Agent Skills

Archyl ships 10 coding agent skills that bring your entire architecture into your coding agent — Claude Code, Codex, Cursor, or any compatible tool. Instead of switching between your editor and the Archyl dashboard, your agent can validate changes before you code, document what shipped, review pull requests against your C4 model, and forecast architectural drift — all from the terminal.

The skills are open source and available at github.com/archyl-com/agent-skills.

The AI-Native Architecture Workflow

The 10 skills work together to form a continuous architecture loop:

preflight → code → review → CI (GitHub Actions) → postship → generate context
    ↑                                                              |
    └──────────────────────────────────────────────────────────────┘

Prerequisites

• An Archyl account with API access
• An API key (get one from Settings > API Keys in the Archyl dashboard)
• Claude Code, Codex, Cursor, or a compatible coding agent

Installation

Step 1: Add the Marketplace

Run the following command in Claude Code:

/plugin marketplace add archyl-com/agent-skills

Then configure auto-updates:

1. Run /plugin
2. Select Marketplaces
3. Choose archyl-marketplace
4. Select Enable auto-update

Step 2: Install All 10 Skills

/plugin install archyl-developer@archyl-com-agent-skills
/plugin install archyl-preflight@archyl-com-agent-skills
/plugin install archyl-postship@archyl-com-agent-skills
/plugin install archyl-changelog@archyl-com-agent-skills
/plugin install archyl-review@archyl-com-agent-skills
/plugin install archyl-dora@archyl-com-agent-skills
/plugin install archyl-autofix@archyl-com-agent-skills
/plugin install archyl-roi@archyl-com-agent-skills
/plugin install archyl-predict@archyl-com-agent-skills
/plugin install archyl-orchestrate@archyl-com-agent-skills

Restart your coding agent after installation.

Step 3: Configure the MCP Server

Add the Archyl MCP server to your project's .mcp.json:

{
    "mcpServers": {
        "archyl": {
            "type": "http",
            "url": "https://api.archyl.com/mcp",
            "headers": {
                "X-API-Key": "arch_your_api_key_here"
            }
        }
    }
}

Replace arch_your_api_key_here with your actual API key from the Archyl dashboard.

Other Coding Agents

The skill files are compatible with any agent that supports the plugin format. You can also use them directly from the agent-skills repository for Cursor, Codex, or other tools.

Quick Setup

The fastest way to get started is the setup script. It generates all the configuration files your agent needs.

The Setup Script

Run from your project root:

npx archyl-setup

This creates three files:

Template: CLAUDE.md

The generated CLAUDE.md includes instructions like:

# Architecture

This project is documented in Archyl (project ID: `proj_xxx`).

## Before coding
Run `/archyl-preflight` to validate your approach against the architecture.

## After shipping
Run `/archyl-postship` to update the C4 model and create ADRs.

## Architecture rules
Always run `/archyl-review` before requesting a code review.

You can customize these templates to match your team's workflow.

Core Skills

archyl-developer

The foundation skill. It gives your agent structured knowledge of Archyl's 200+ MCP tools across these domains:

Example prompts:

Create a new system called PaymentPlatform with containers for
the API server, a PostgreSQL database, and a React frontend.

Create an ADR titled "Migrate from REST to gRPC for internal services".
Set it as proposed, explain the context around latency requirements,
and link it to the ApiGateway and PaymentService containers.

Show me the technology radar. Add Temporal as an adopted workflow
orchestration technology and tag it on the OrderProcessing container.

archyl-preflight

Run before you start coding to validate your planned approach against the existing architecture. Preflight checks your plan against the C4 model, conformance rules, and recent ADRs to catch violations early.

Example prompts:

/archyl-preflight I'm planning to add a new Redis cache between the
API server and the database to reduce read latency.

/archyl-preflight We want to split the UserService into separate
authentication and profile services.

The skill will flag issues like dependency violations, naming conflicts, or approaches that contradict existing ADRs — before you write a single line of code.

archyl-postship

Run after shipping to automatically update your architecture documentation. It analyzes what changed in the codebase and:

• Updates the C4 model (new containers, components, relationships)
• Creates ADRs for significant decisions
• Opens Change Requests for team review when needed

Example prompts:

/archyl-postship We just shipped the Redis caching layer.
Update the architecture to reflect the new cache container
and its relationships.

/archyl-postship Document the authentication service split
we shipped this sprint.

Review and Governance Skills

archyl-review

A structured architecture review bot. It analyzes diffs against your C4 model, conformance rules, and ADRs to provide architecture-aware code review comments.

Example prompts:

/archyl-review Review the current branch against the architecture.
Flag any conformance violations or undocumented dependencies.

/archyl-review Check if PR #42 introduces any new cross-system
dependencies that aren't in the C4 model.

archyl-changelog

Generates an architecture changelog — a timeline of changes including ADRs, releases, conformance checks, drift events, and model updates.

Example prompts:

/archyl-changelog Show the architecture timeline for the last month.

/archyl-changelog What changed in the PaymentPlatform system
since the v2.0 release?

archyl-autofix

When drift is detected between your code and your architecture documentation, autofix proposes concrete fixes — either to the code or to the model — to bring them back in sync.

Example prompts:

/archyl-autofix We have drift on the PaymentService container.
Propose fixes to resolve it.

/archyl-autofix Show all current drift issues and suggest
the fastest path to zero drift.

Intelligence Skills

archyl-dora

Correlates architecture changes with DORA delivery performance metrics. See how architectural decisions impact deployment frequency, lead time, change failure rate, and mean time to recovery.

Example prompts:

/archyl-dora Show DORA metrics for the last quarter.
Did the microservice split improve deployment frequency?

/archyl-dora Correlate recent architecture changes
with our change failure rate trend.

archyl-roi

Calculates the financial impact of architecture decisions. Estimates time saved, incidents prevented, and developer productivity changes from architectural improvements.

Example prompts:

/archyl-roi What's the estimated ROI of our migration
from monolith to microservices?

/archyl-roi Calculate the cost of our current architectural
drift vs the cost of fixing it.

archyl-predict

Forecasts future architectural issues before they happen. Uses historical trends to predict drift, DORA regressions, and complexity hotspots.

Example prompts:

/archyl-predict Which components are most likely to drift
in the next 30 days?

/archyl-predict Based on current trends, will our deployment
frequency regress this quarter? Which services are at risk?

Orchestration

archyl-orchestrate

Coordinates multiple agents working on the same codebase. Handles API contract negotiation between services, dependency conflict resolution, and ensures agents don't make conflicting architecture changes.

Example prompts:

/archyl-orchestrate Two agents are modifying services that share
an API contract. Coordinate the changes to avoid conflicts.

/archyl-orchestrate Agent A is adding a new field to the
UserService API. Check if Agent B's PaymentService integration
will break.

This skill is particularly useful in multi-agent setups where different agents own different services and need to negotiate shared contracts without stepping on each other.

Conformance Rule Packs

Archyl ships pre-built conformance rule packs for common architecture patterns — microservices, event-driven, layered, and more. These rule packs work with all the skills above to enforce your architecture automatically.

See the Conformance Rules guide for details on available rule packs and how to create custom rules.

SDKs

If you want to integrate Archyl into custom tooling beyond coding agents, SDKs are available for TypeScript, Python, and Go.

See the MCP Server documentation for SDK details and API reference.

How It Works

Each skill provides your coding agent with structured knowledge about specific Archyl MCP tools — including parameters, expected values, and best practices. When you ask your agent to perform an architecture task, it:

1. Identifies which MCP tools to call based on the skill's knowledge
2. Constructs the correct parameters (project IDs, element types, relationship types)
3. Chains multiple calls together for complex workflows
4. Returns a summary of what was created, modified, or flagged

The agent always starts by calling list_projects to discover available projects and get the projectId needed for subsequent operations.

C4 Model Reference

The skills understand all 4 levels of the C4 model:

Relationship Types

When connecting elements, the agent uses the appropriate relationship type:

Contributing

The skills are open source. You can contribute by:

• Fixing tool names, parameters, or descriptions
• Adding coverage for new Archyl features
• Improving workflow examples
• Creating new skill files for additional use cases

See the contributing guide for details.