Skill Maker logo

Skill Maker

Organization
AlpacaLabsLLC
skill-maker

Create or update an Arch Studio skill for Codex or Claude Code using the host's native skill maker when available, with Arch Studio governance and validation. Use when asked to create, package, adapt or revise a reusable skill.

Overview

PublisherAlpacaLabsLLC
Repositoryskills-for-architects
Skill nameskill-maker
Stars
386
Forks
81
Bundled files
3
LicenseMIT
Links
  • Markdown instructions

    A SKILL.md file the model loads on demand, so it only costs tokens when a request actually matches.

  • Works with any LLM

    AI skills are plain Markdown, not provider-specific code, so this works with GPT, Claude, Gemini, Grok, or a local model.

  • 3 bundled files

    Scripts, templates, and references the model can read while it works. Files are read-only and never executed.

  • Open source

    Published by AlpacaLabsLLC on GitHub. Read the source before you install it.

Installation

Install the Skill Maker AI skill in TypingMind to use it with any LLM, or drop it into another agent that reads SKILL.md.

1

Install in TypingMind

TypingMind installs a skill straight from its GitHub folder — it reads SKILL.md, bundles the resource files, and stores the result locally.

  1. Open the app and go to Plugins → Skills.
  2. Choose "Install from GitHub".
  3. Paste the skill folder URL below and confirm.
    https://github.com/AlpacaLabsLLC/skills-for-architects/tree/main/skills/skill-maker
  4. Enable the skill in any chat where you want it available.
Plugins → Skills → Add skill → From GitHub URL, then paste the folder URL and press Continue.
2

Install in another agent

Any agent that reads the Agent Skills format can use this skill — copy the folder into that agent's skills directory.

Claude Code — .claude/skills
git clone --depth 1 https://github.com/AlpacaLabsLLC/skills-for-architects.git /tmp/skills-for-architects
mkdir -p .claude/skills
cp -r /tmp/skills-for-architects/skills/skill-maker .claude/skills/skill-maker
Restart Claude Code after copying so it picks up the new skill.

Use it in TypingMind

Enable Skill Maker in any TypingMind chat and the model takes it from there. Its name and description sit in the system prompt, and the moment a request matches, the model loads the full instructions itself — you never invoke it by hand, and it costs no tokens until it is actually used.

The model loads Skill Maker on its own as soon as a request matches it.

Works with any AI model

AI skills are plain Markdown instructions rather than provider-specific code, so Skill Maker is not tied to the model it was written for. Install it once in TypingMind and use it with GPT-5, Claude, Gemini, Grok, DeepSeek, Mistral, Llama, or a local model you run yourself — all on your own API keys.

  • Loaded only when it is needed

    The system prompt carries just the name and description. The instructions are fetched on the first matching request, so an idle skill costs nothing.

  • Switch models mid-chat

    Because the skill is instructions rather than code, changing model does not break it — the next model reads the same SKILL.md.

Skill instructions

This is the SKILL.md content the model loads. Read it before installing — a skill is instructions your model will follow.

/as:skill-maker — Author a governed skill

Use the active host's native skill maker when available. If none exists, write the minimum skill in that host's supported format. The host owns generic authoring technique; this skill supplies Arch Studio's target, governance and acceptance requirements. Do not require a particular host maker or install an Arch Studio runtime.

Read PATTERNS.md and follow its owning links as relevant: architecture, host contract, host adapters, workspace model, terminology, and contribution rules. Read this component's declaration (skill:skill-maker) and only its applicable modes from the shared catalog. For MCP delivery, retrieve all required resources at the advertised release digest; resource references are not assumed local paths.

Target

Derive ordinary authoring choices from the request; do not run a routine setup interview. Ask only for missing scope, target authorization or a concrete governance conflict.

Resolve the exact target before writing. Catalog detection has highest priority: find the Git root and check whether .codex-plugin/plugin.json or .claude-plugin/plugin.json names as. A plugin cache or MCP resource is not a writable source checkout. Otherwise find the nearest STUDIO.md for a normal firm skill; do not let a nearer project silently override a resolved studio. Use the nearest project root only when the user explicitly requests a project-only skill. If no root is established, ask one target question rather than treating the current directory as a studio. A global target requires an explicit request.

ScopeDestination
Verified catalog checkout{project-root}/skills/{name}/
Studio{studio-root}/{host-skill-root}/{name}/
Explicitly project-only{project-root}/{host-skill-root}/{name}/
Explicitly global{host-global-skill-root}/{name}/

Use .agents/skills for Codex or .claude/skills for Claude Code; global roots are $HOME/.agents/skills and $HOME/.claude/skills respectively. If the host is ambiguous, ask which target host. State the selected absolute path. The installed plugin cache is never a private-skill target. Check existing contents; update a named existing skill only when the request authorizes it. Otherwise choose a distinct name or ask. Project-only discovery may be narrower when launched from a nested repository; explain that limitation without duplicating the skill.

Live studio governance

Read the complete studio policy contract. For a relevant studio/project procedure, resolve the owning studio using the context contract, read its recorded current policy when needed to establish the procedure, and add the contract's live-reference step to the generated SKILL.md with a dependency explanation in README.md. The generated step resolves the current studio and rereads its central policy by an observed host operation on each invocation and before resumed policy-dependent actions; a claim that a read occurred is not read evidence. It handles unreadable references and conflicts explicitly, preserves existing authorization, and keeps the observed policy revision and operation order in any requested evaluation evidence. Embed portable instructions, not policy text or a dependency on this plugin's installed path.

Skill Maker never writes STUDIO.md or adopts a policy. No policy/decline leaves existing governance in force. Standalone/global skills do not require a studio. Public-catalog outputs use generic lookup where relevant and contain no originating policy text, private locator or studio identity in any bundle file. Existing generated skills are changed only by an explicit update request; no automatic adoption or organization-wide installation is implied.

Author

Check existing owners before adding a capability. Give the skill one coherent outcome, a trigger description, necessary domain facts, interfaces, invariants, evidence and a done condition. Let the host choose valid methods. Include an ordered procedure only when its order is itself required and explain why. Keep firm and project facts in their owning workspace; link to governing sources rather than copying them.

Create SKILL.md and a short human-facing README.md. For a host without a native maker, adapt the bundled SKILL example and README example; use them as examples, not mandatory prose or sequence. Use a kebab-case name matching the directory. Describe both what the skill does and when to use it. Include allowed-tools only when supported and needed by the selected host. Do not embed ~/ paths. For code, zoning or life-safety analysis retain the canonical disclaimer and <!-- architecture-studio:requires-disclaimer --> marker as required by the rules.

For any files created or changed, follow the native mutation sequence for the complete affected set, including existing bytes, access, recovery, stale-write protection and fresh readback. Before any destination write, durably retain and separately reopen the complete original and prepared file/access set, including README and any requested validation report. That preparation check verifies only the retained preparation: never present comparison of a temporary or prepared file with itself as destination verification. Publish complete bytes with no-clobber or stale-write protection, then perform a new observed read of the actual destination path and check the entire affected set. Inspect incomplete attempts before retries. Do not treat preparation as a new user approval gate. Stop before mutation when required access or recoverable publication is unavailable.

Verify and finish

Run the host maker's checks when available. Independently apply skill_scaffold.validate semantics: the directory is kebab-case; readable README.md and UTF-8 SKILL.md exist; the latter starts with delimited YAML frontmatter whose safely parsed mapping has a matching name and nonblank description; no ~/ occurs anywhere. A missing YAML parser leaves that check unverified, never passed. Accept exactly {"directory": "<selected path>"} with a required string and no extra fields; require regular readable files and a directory matching [a-z0-9]+(?:-[a-z0-9]+)*. Frontmatter begins at the first byte with --- and LF or CRLF, closing on a separate --- line followed by newline or end of file. On success, report {"valid": true, "directory": "<actual input path>", "name": "<directory name>"} only after actual destination readback; on failure identify the failing check, fix only authorized files and rerun the complete check. The validator is read-only. This structural check does not prove discovery, policy access or usefulness. Review the whole bundle for the applicable live-reference step, README dependency, policy privacy and destination/publication constraints.

For a catalog contribution, run repository lint in the verified source checkout and relevant focused tests; check catalog membership and host contracts. A private skill need not run catalog lint. If behavior is uncertain, compare representative tasks with and without the skill; report observed value, not an assumed lift. Report the paths, invocation ($name on Codex, /{name} privately or /as:{name} in the Claude catalog), checks and any incomplete verification. Do not commit unless requested.

Bundled files

The model reads these on demand while the skill is loaded. They are exposed as readable files and are never executed.

Frequently asked questions

What does the Skill Maker AI skill do?

Create or update an Arch Studio skill for Codex or Claude Code using the host's native skill maker when available, with Arch Studio governance and validation. Use when asked to create, package, adapt or revise a reusable skill.

Why use Skill Maker on TypingMind?

Because you install it once and use it with any model. Skill Maker is plain Markdown rather than provider-specific code, so the same skill runs on GPT-5, Claude, Gemini, Grok, or a local model — and you can switch model mid-chat without it breaking. TypingMind runs on your own API keys, so you pay providers directly instead of a per-seat subscription, and your skills and chats stay in your own storage.

How do I install Skill Maker in TypingMind?

Open Plugins → Skills → Install from GitHub in TypingMind and paste https://github.com/AlpacaLabsLLC/skills-for-architects/tree/main/skills/skill-maker. TypingMind reads its SKILL.md and bundles its files and installs it as a skill you can enable per chat.

Which AI models can use Skill Maker?

Any model you connect in TypingMind. AI skills are plain Markdown instructions rather than provider-specific code, so GPT, Claude, Gemini, Grok, and local models can all load this skill when a request matches it.

How many AI models can I use with Skill Maker?

As many as you like. As long as a model supports skills, you can use Skill Maker with it — GPT, Claude, Gemini, Grok, DeepSeek, Mistral, Llama and more — all on TypingMind with your own API keys.

Is the Skill Maker AI skill free?

Yes. It is published on GitHub by AlpacaLabsLLC under the MIT license. You only pay your own AI provider for the tokens you use.

What are AI skills?

An AI skill is a reusable instruction bundle that teaches an AI model how to do one specific task. It follows the open Agent Skills format: a SKILL.md file with a name and description, plus any scripts, templates or reference files the model may need. The model reads the instructions only when your request matches the skill, so an installed skill costs nothing until it is used.

How are AI skills different from plugins or MCP servers?

A plugin or MCP server gives a model new tools to call — code that runs somewhere and returns a result. An AI skill gives the model knowledge and process instead: how to approach a task, which steps to follow, what good output looks like. Skills are plain Markdown, so they need no server, no API key and no runtime, and they work with any model.

View all

Set up your own AI workspace now

Get notified about new features and future giveaways by subscribing to our newsletter 👇