One-click install
npx skills add https://github.com/Kyonax/dot-files --skill skill-architect-kyonax
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: skill-architect
Source: https://github.com/Kyonax/dot-files/tree/main/.config/doom-mac/gptel-directives/skills/skill-architect
Command: npx skills add https://github.com/Kyonax/dot-files --skill skill-architect-kyonax

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill solves the common pain points of building AI skills that waste tokens through unnecessary over-loading, fail to trigger correctly for relevant user tasks, break across different AI agents like Claude Code and GPTel, or become unmaintainable monolithic knowledge dumps. It provides a complete, validated methodology for engineering skills that adhere to the Agent Skills Specification and Two-Agent Model for optimal performance and portability.

Core Features & Use Cases

  • End-to-End Skill Creation SOP: A mandatory 5-phase process for building new skills from ground truth mining to testing, ensuring accurate routing and complete rule coverage.
  • Skill Refinement Patterns: Proven workflows for splitting monolithic skills into atomic rules, updating existing skills without breaking routing, and promoting stable session guidelines into permanent skill rules.
  • Multi-Agent Compatibility: Guidance for setting up skills to work seamlessly across Claude Code, GPTel, Cursor, and other agents, including symlink configuration and context budget management.
  • Rule Authoring Best Practices: Standards for writing atomic, self-contained, exhaustive rule files with correct YAML frontmatter for accurate analyzer routing.
  • Use Case: If your team has a 1200-line monolithic skill that loads all its content on every request, use this Skill to split it into 6 focused rule files that load only when needed, reducing token waste by over 60% while improving output accuracy.

Quick Start

Use the skill-architect skill to create a new skill for your team's API design conventions, following the 5-phase creation SOP to ensure it routes correctly and loads only the relevant rules for API-related tasks.

Frequently Asked Questions about skill-architect

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I split a monolithic AI skill into smaller files to reduce token waste?

Split monolithic AI skills by breaking them into atomic, self-contained rule files using the Two-Agent Model, ensuring only relevant rules load per request to significantly reduce token waste and improve routing accuracy.

What is progressive disclosure in AI agents and how does it optimize token usage?

Progressive disclosure in AI agents is an implementation pattern where skills load context incrementally rather than all at once, eliminating unnecessary token consumption by triggering only the specific rules required for the current task.

How do I write AI skill rules that trigger reliably across Claude Code, GPTel, and Cursor?

Write reliable cross-agent AI skill rules by using keyword-dense triggering descriptions, correct YAML frontmatter, and multi-agent compatibility setups like symlink configuration to ensure seamless routing across Claude Code, GPTel, and Cursor.

What is the best way to create a new AI skill from scratch without routing failures?

Create new AI skills without routing failures by following a mandatory 5-phase creation SOP, moving from ground truth mining through testing to ensure complete rule coverage and accurate analyzer routing.

Can I update existing skill rules without breaking the current SKILL.md routing table?

Update existing skill rules without breaking routing by applying proven skill refinement patterns that maintain keyword-dense descriptions and atomic file structures, preserving the integrity of the SKILL.md routing table.

When should I avoid using a single monolithic skill for AI agent workflows?

Avoid using a single monolithic skill when it grows too large and loads all content on every request, causing token waste; instead, split it into focused rule files that load only when needed for better maintainability.