Help & Documentation

Learn how to get the most out of AI SkillsBank.

Getting Started

You can use most of AI SkillsBank without signing up. Pick whichever entry point fits where you are right now — an account becomes useful once you want to save and share what you've built.

Browse the public library

From the homepage, click Browse Skills to explore community-built skills. Sort by trending, newest, top-rated, or most-forked, and filter by category. Open any skill to see its full content, supporting files, ratings, and how many people have forked it.

Try a skill on the spot

On any public skill page, click ⚡ Try this skill. Fill in the template variables (or send a plain message) and the skill runs against Claude Haiku immediately — no account, no setup. The response appears below the form, capped at a short length so you can see how the skill behaves. Anonymous demos are limited to a few runs per IP per day so the free tier stays free for everyone.

Build a skill with the Guided Builder

Click Build a skill from the homepage to start a conversational draft. Tell it what you want the skill to do, answer a few short follow-ups, and it produces a complete skill draft (content, variables, supporting files) you can preview and save. Guests get a few sessions per week per IP; signing in removes the cap.

Create an account when you want to save and publish

You'll need an account to save skills to your library, fork others' work, build agents, share with a team, or publish publicly. Two ways to sign up:

• Continue with Google or GitHub — one-click signup; no verification email required.
• Email & password — register, click the verification link we email you, then log in.

Free accounts include up to 10 skills, 5 agents, and 5 kits, with all the core features unlocked (forking a kit never counts against the agent cap). See Premium & Billing for what the optional $5/month plan adds.

Signing In

Open the Log in / Sign up dialog from the top navigation. There are three ways in, and they all land on the same account:

• Continue with Google — click the button, approve on Google's screen, and you're in. No password, no verification email.
• Continue with GitHub — same one-click flow via your GitHub account.
• Email & password — register with an email and password, click the verification link we email you (the link auto-confirms your address), then log in.

If you sign up with Google or GitHub using an email that already has a password account (or vice-versa), the two are linked to the same account automatically — you won't end up with duplicates.

Linking providers later

Open Settings from the user menu (top-right) to manage how you sign in. Under Linked accounts you can connect Google or GitHub for one-click login. You'll always need at least one working method — a password or a linked provider — so the app won't let you remove your last one.

💬 Guided Builder

The Guided Builder is a short conversational flow that turns "I want a skill that does X" into a complete, structured skill draft — without you having to write the prompt yourself. It's the fastest way to get from idea to working skill, especially if you've never written an LLM instruction before.

How it works

1. Click Build a skill on the homepage (no sign-in needed) or open the builder from your dashboard.
2. Describe what you want your skill to do in plain language.
3. The assistant asks a few quick follow-up questions — the use case, the tone, who's going to use it — with quick-reply chips you can click instead of typing.
4. When it has enough context, it generates a draft: title, category, content (with {{variable}} placeholders), tags, and any helpful supporting files.
5. Review the preview. Save the draft to your library (sign in if you haven't yet), or start over with a different brief.

Guest vs. signed-in

Anonymous guests can start a small number of builder sessions per IP each week so the free tier doesn't get abused. Once you sign in (Google, GitHub, or email), the per-IP cap goes away and your draft is attached to your account. If you started a session as a guest and then signed up, the draft is moved over automatically.

Guided Builder vs. AI Skill Creator

Both produce a complete skill from natural language. The difference is the interaction style:

• Guided Builder — conversational, with follow-up questions and quick replies. Best when you're not sure exactly how to specify what you want, or you're new to prompt design.
• AI Skill Creator — one-shot. You write a single description and it generates the skill directly. Best when you already know exactly what you want.

Creating & Editing Skills

There are two ways to create a skill:

• New Skill — fill in the form manually with your own content
• ✨ AI Create — describe what you want in plain English and let AI generate the full skill for you (see AI Skill Creator)

Each skill has:

• Title — a short, descriptive name
• Category — choose from predefined categories to organize your skill
• Content — the instruction text your AI agent will use (Markdown supported)
• Tags — comma-separated keywords for easier searching

To edit a skill, open it and click Edit. Each edit automatically saves a snapshot of the previous version so you can always go back.

✨ AI Skill Creator

The AI Skill Creator generates a complete, structured skill from a plain-English description. Click ✨ AI Create in the dashboard header to open it.

How it works

1. Describe what you want your AI agent to do in the text box (up to 2,000 characters)
2. Select a model — Haiku 4.5 (fast) or Sonnet 4.6 (richer output, premium only)
3. Click Generate Skill
4. Review the generated title, category, content, tags, and any supporting files
5. Click Use This Skill to load it into the skill form for final review before saving, or Regenerate to try again

What gets generated

• Title & category — inferred from your description
• Content — a structured prompt with {{variable}} placeholders for dynamic inputs
• Tags — 3–6 relevant keywords
• Supporting files — up to 2 files (one per type: example, reference, template, or script) if they genuinely add value

Scope rules

The AI creates one skill for one task. If your description covers multiple platforms or formats, it picks the primary one and notes that you can use the Skill Optimizer to convert for other targets later.

Free vs. Premium limits

Feature	Free	Premium
Model	Claude Haiku 4.5	Haiku 4.5 or Sonnet 4.6
Output token budget	4,096 tokens	16,000 tokens
Supporting file size	300–500 tokens each	500–2,000 tokens each

🔄 Skill Optimizer

The Skill Optimizer converts an existing skill to a specific agent platform or harness format. It's useful when you want to take a skill you've built in AI SkillsBank and deploy it somewhere else without rewriting it from scratch.

Premium feature. Open any skill, click 🔄 Optimize, choose a target format, and click Optimize.

Supported target formats

• Claude Code (SKILL.md) — Markdown layout following the Anthropic Agent Skills spec, with {{variable}} syntax
• Codex — System prompt structured for OpenAI models; variables converted to appropriate markers
• Cursor Rules (.cursorrules) — Project-level rules focusing on coding conventions and constraints
• Custom GPT Instructions — Formatted for the OpenAI GPT builder: personality, capabilities, constraints, conversation starters
• Generic System Prompt — Clean, platform-agnostic output that works with any LLM

Output

The optimizer returns the converted content plus brief notes explaining the key adaptations. Use the Copy button to copy the optimized text to your clipboard.

Template Variables

Use {{variable_name}} placeholders anywhere in your skill content. When you use the skill, you'll be prompted to fill in each variable before copying the final output.

This is useful for reusable instructions where only certain details change — for example, {{project_name}}, {{language}}, or {{tone}}.

Supporting Files

You can attach supporting files (reference docs, example scripts, config files) to any skill. These files are bundled with the skill and included when someone forks it, so the full context travels with the instruction.

Version History

Every time you edit a skill, the previous version is saved automatically. You can:

• View the full history of changes
• Compare any two versions side-by-side
• Restore a previous version with one click

✓ Evals (Behavior Testing)

Evals turn your skills into tested behaviors. Attach test cases to any skill you own, run them on demand, and see exactly which assertions pass or fail — before an edit slips into production.

Opening the evals panel

Open any skill you own from your dashboard, then click the ✓ Evals button at the bottom of the detail view (next to History). The panel shows a header badge like "3/4 passing", a list of your evals, and an Add eval button. The button is owner-only — collaborators on team-shared skills cannot create evals.

Anatomy of an eval

Each eval has three parts:

• Name — a short label like "Late delivery, warm tone"
• Input — either a free-text user message or a set of {{variable}} values to substitute into the skill content. Switch modes with the toggle in the form.
• Assertions — the conditions that must hold on the LLM's output. Add up to 10 per eval.

Assertion types

Type	Passes when…
contains	Output contains the given text (toggle "ignore case" if needed).
not_contains	Output does not contain the given text.
matches	Output matches the supplied regex pattern.
min_length	Output is at least N characters long.
max_length	Output is at most N characters long.
judged_pass	An LLM judge (Claude Haiku) decides the output meets your natural-language criterion, e.g. "Response uses a warm but professional tone and addresses the customer by name."

You can mix and match. judged_pass is the most flexible but slowest — capped at 3 per eval to control cost.

Running evals

• Run one — click the ▶ Run button on a single eval row. The row expands to show the LLM output, status badge (pass / fail / error), latency, and a per-assertion checklist with the reason each assertion did or didn't pass.
• Run all — click ▶ Run all in the section header. Each eval runs sequentially, and the section badge updates to "X/Y passing" when finished.

Editing an eval

Click the ✎ (edit) icon on any eval row to open the form pre-filled with that eval's name, input, and assertions. Save your changes and the eval is updated — run history is preserved so you can see how the same test behaved before and after the edit.

Public eval-status badge

Once a public skill has at least one eval with a recorded run, a small badge appears on its public page (e.g. "✓ 12/12 evals passing") right alongside the fork count and review stars. This signals to people considering forking your skill that the behavior is tested.

Limits and cost controls

• Up to 25 evals per skill.
• Up to 10 assertions per eval, with 3 judged_pass max (each judged assertion costs an extra LLM call).
• Eval runs use Claude Haiku 4.5 and are bounded by a per-user daily budget plus a 20-runs-per-hour rate limit. If you hit the budget you'll see a friendly 503 message and can resume the next day.

Best practices

• Cover the unhappy paths. One eval that catches a regression you've already seen is worth ten happy-path ones.
• Combine fast and slow assertions. Use cheap pattern checks (contains, matches, min_length) for structural guarantees, and reserve judged_pass for tone, persona, or correctness criteria a regex can't express.
• Re-run after edits. Evals don't auto-run on save (yet), so click Run all after meaningful content changes to confirm nothing regressed.
• Read the failure messages. When an assertion fails, the row shows exactly what was expected vs. what was returned — usually enough to diagnose the issue without leaving the page.

🧮 Agents Overview

An agent is the unit above a single skill. Where a skill is one instruction module, an agent is a complete, runnable bundle — a personality, a set of skills, the things it knows, the things it remembers, the tools it can reach, and the rules it must never break. You design the agent in plain language, AI SkillsBank writes the files, and you export it to run in Claude Code, Cursor, ChatGPT, an MCP server, or plain Markdown.

Every agent is made of six parts:

• Soul — who the agent is: its identity, principles, and operating instructions (its SOUL.md). The soul is versioned, just like a skill.
• Skills — reusable instruction modules attached to the agent. These are the same skills you already build — an agent references them, so improving a skill improves every agent that uses it.
• Knowledge files — documents and reference material the agent reads (FAQs, policies, specs) — what it knows.
• Memory files — notes the agent keeps and updates as it works, so context persists across sessions. The generated soul always instructs the agent to keep these current.
• Tools — capabilities the agent can invoke (web search, code runner, APIs), declared so the destination harness knows what to enable.
• Guardrails — hard rules: what it must never do (forbidden), always do (required), how to communicate (tone), and what's in or out of scope (scope).

Find your agents under the Agents tab on your dashboard. Free accounts can create up to 5 agents; Premium is unlimited. Skills haven't gone anywhere — they're still versioned and forkable, and now they're the building blocks agents are made of.

Creating an Agent

On the dashboard, switch to the Agents tab and click + New Agent. You'll be offered three ways to start:

• ✨ Describe it — write a plain-language brief (for example: "a customer-support agent for my store that answers order and return questions, stays friendly but concise, and never invents refund amounts"). AI scaffolds the whole bundle — soul, skills, knowledge and memory files, tools, and guardrails — and shows you a preview to review.
• ⇩ Import existing — paste an existing CLAUDE.md, AGENTS.md, .cursorrules, or similar config. AI reads it, shows how it interpreted the file, and converts it into an editable agent bundle.
• □ Start blank — create an empty agent and build every component yourself in the composer.

With Describe or Import, you review the generated draft — title, description, skills, files, tools, and guardrails — then click Save as agent & open composer. Nothing is saved until you confirm, and you can Start over from the preview to try a different brief.

The Agent Composer

The composer is the single-page workspace for one agent. The left rail is the bundle outline — click any item to edit that component:

• Soul — a large editor for the agent's SOUL.md. Every save snapshots the previous soul into version history.
• Skills — attach existing skills from your library, reorder them, or remove them. Up to 20 skills per agent.
• Knowledge and Memory — add, edit, and delete files (up to 30 total across both types). Filenames are unique within an agent.
• Tools — declare up to 25 tools, each with a name and description, plus optional JSON config.
• Guardrails — add up to 20 rules, each tagged forbidden, required, tone, or scope.
• Evals — behavior tests for the whole bundle (see Agent Evals).

The composer header has Simulate, Export, Version History, Edit Details, and Save. Editing the soul and saving creates a restorable version — open Version History to roll back to any earlier state.

Simulating an Agent

Premium feature. Click ▶ Simulate in the composer header to test the whole agent. Enter a test message, pick a model (Haiku or Sonnet), and run.

The simulation compiles every component — soul, guardrails, skills, knowledge, and memory — into one system prompt and makes a single model call. This is faithful to how a real harness injects context: one model, reading everything at once. It is a faithful rehearsal, not a guarantee.

Below the response you'll see an attribution trace: a likelihood gauge (high / medium / low) indicating which bundle components appear to have influenced the answer. The trace is self-reported by a second model call — treat it as plausible attribution, not proven causation. A disclaimer to that effect appears with every trace.

Agent Evals

Agent evals work like skill evals, but run against the whole compiled agent bundle instead of a single skill. Open the Evals section in the composer rail.

Each eval has a name, a test message, and one or more assertions — contains, not_contains, matches, min_length, max_length, and the LLM-judged judged_pass (see the Evals section for how each type behaves). Use + Add eval to create one, the ▶ button to run a single eval, or Run all to run every eval and get a passing / failing / errored summary. Click the eye icon on any eval to open its run history with per-assertion results and the agent's output.

Up to 25 evals per agent. Runs use Claude Haiku and draw on the same per-user daily eval budget as skill evals, so if you hit the budget you'll see a friendly message and can resume the next day.

Exporting an Agent

Click ↓ Export in the composer header to download your agent as a ready-to-run package. Pick a target format and the files are laid out exactly how that tool expects them:

Format	Package layout
Claude Code	CLAUDE.md plus skills/, knowledge/, memory/, and tools.json
Cursor	.cursorrules with the full compiled bundle
ChatGPT	system_prompt.md plus a files/ folder of knowledge documents to upload
MCP Server	mcp_config.json plus SOUL.md
Portable Markdown	a single AGENT.md with the entire bundle

The export modal shows a live manifest of every file in the package before you download the .zip. Change the agent later and re-export in seconds — you're never locked in.

🧰 Kits (Team Playbooks)

A kit is the unit above an agent: a curated collection of agents you manage, share, and fork as a single unit. If a skill is one capability and an agent is one role, a kit is a whole team — for example a "Customer Support Kit" that bundles a frontline support agent, an escalation manager, a knowledge-base writer, and a voice-of-customer analyst.

The progression is skill → agent → kit: reusable capabilities compose into roles, and roles compose into a team playbook your whole team can work from.

Creating & editing a kit

Open the Kits tab on your dashboard and click + New Kit. Give it a title, category, and description, then pick which of your agents belong to it. Re-open a kit any time to rename it, change its description, or adjust which agents are in it.

Forking a kit

Forking a kit copies every agent inside it into your own library in one click — each agent arrives complete with its skills, knowledge/memory files, tools, and guardrails. Forking a kit is never blocked by the free-tier agent cap, so you can pull in a whole playbook and start customizing immediately. Browse the Starter kits on the home page for ready-made playbooks (agency, support, sales, founder ops) to fork and make your own.

Sharing a kit

Like skills and agents, a kit can be public (forkable by anyone), private (just you), or team-shared — share a private kit with a team you belong to and every member can view and fork it. See Public, Private & Team Sharing.

Forking Skills

Found a public skill you'd like to customize? Click Fork to copy it into your own library. Forked skills are independent — you can edit them freely without affecting the original. The fork count on the original skill shows how many users have built on it.

Agents can be forked too: forking an agent copies its soul, skill attachments, and knowledge/memory files into a new agent you own.

Public, Private & Team Sharing

• Public — visible to everyone, can be forked and reviewed by the community
• Private — only visible to you (indicated by a red "Private" badge on the card)
• Team Shared — private skills, agents, or kits can be shared with specific teams you belong to (indicated by a blue "Shared" badge)

Toggle visibility at any time from the skill or agent detail view.

Team sharing for agents: the same flow works for agents — open Edit Details in the composer and check the teams you want to share with. Team members can view and edit the whole bundle (soul, skills, files, tools, guardrails, evals). Only the owner can change visibility, manage the share list, or delete the agent.

Ratings & Reviews

Public skills can be rated and reviewed by other users. Leave a 1–5 star rating and optional written feedback. Each user can submit one review per skill — submitting again updates your existing review. Average ratings are shown on skill cards to help surface the best content.

Security Scanning

Public skills are automatically scanned for security issues before they're shared with the community. AI SkillsBank uses a three-tier scan pipeline to detect risky content, including malicious patterns, prompt injection attempts, and exposed secrets.

Scan results appear on:

• Skill cards
• The skill detail page

Each scanned skill shows:

• Overall status
• Last scan time
• Results for each scan tier
• A short explanation of what was found

Statuses

• Scanned (green) — passed all checks
• Flagged (yellow) — potential concerns detected
• Rejected (red) — security issues found
• Incomplete (gray) — scan still in progress

Scan Tiers

• Tier 1: Pattern Scan — checks for known risky patterns and obvious secret exposure
• Tier 2: Heuristic Scan — looks for suspicious instruction structures or behaviors
• Tier 3: AI Scan — reviews the skill in context for higher-level misuse or prompt injection risk

You can also manually re-run a scan from the skill detail page.

Important: A passed scan reduces risk, but does not guarantee a skill is safe in every environment. Review public skills before using them with production systems or sensitive data.

Skill Testing Sandbox

Premium users can test their skills before publishing using the ⚡ Test Sandbox button on any skill detail page. There are two modes:

Advisor Review

An AI prompt engineer evaluates your skill and returns structured feedback:

• Overall rating — Excellent, Good, Needs Work, or Poor
• What works well — strengths in the current prompt
• Issues to address — areas that may cause problems
• Suggestions — concrete improvements to try

You can optionally include a sample test message to also get feedback on how the agent would respond to a specific input.

Test as Agent

Your skill content becomes the agent's system prompt verbatim. Send any message and see how an AI following those instructions would actually respond — useful for catching edge cases before going public.

Template Variables

If your skill uses {{variable}} placeholders, the sandbox will show fill-in fields for each one. Values you enter are substituted into the skill before the test runs, so you're testing the final rendered output.

Model

Choose between Claude Haiku 4.5 (fast) or Claude Sonnet 4.6 (deeper analysis) for each test run.

Premium & Billing

The free tier allows up to 10 skills, 5 agents, and 5 kits. AI SkillsBank Premium is $5/month and includes:

• Unlimited skills & agents — no 10-skill or 3-agent caps
• All current & future features
• ▶ Agent Simulation — run your whole agent bundle and see a component-attribution trace before you ship (see Simulating an Agent)
• Skill Testing Sandbox — advisor review and live agent testing
• ✨ AI Skill Creator (enhanced) — Claude Sonnet 4.6 model, 16,000 token budget, richer supporting files (500–2,000 tokens each). Free users can also use the creator with Haiku 4.5 and a 4,096 token budget.
• 🔄 Skill Optimizer — convert any skill to Claude Code, Codex, Cursor Rules, Custom GPT, or Generic format

Building agents — describing, importing, composing, running evals, and exporting — is free for everyone, subject to the 3-agent cap. Simulation is the one agent feature reserved for Premium.

Subscribing

1. Click the ⚡ Upgrade button in the top navigation bar (visible to free users)
2. Review what's included and click Subscribe for $5/month
3. You'll be redirected to a secure Stripe checkout page — enter your card details and confirm
4. Once payment is complete, Stripe redirects you back to AI SkillsBank and your account is upgraded immediately

Managing Your Subscription

1. Click the ⚡ Premium button in the top navigation bar
2. Click Manage Billing & Subscription
3. You'll be redirected to the Stripe customer portal where you can update your payment method, view invoices, or cancel

Cancellations take effect at the end of your current billing period. Your skills and data are not affected if you cancel.

Teams

Create a team to collaborate with others:

1. Go to Teams and click Create Team
2. Share your team's invite code with members
3. Members join by entering the code in the Join Team dialog

Once in a team, you can share private skills with that team so all members can access them.

🔑 Personal Access Tokens

A personal access token lets your own AI agent, a script, or any tool reach your content — including private and team-shared skills, agents, and kits — over the REST API or MCP, with no browser login. A token looks like skb_… and acts on your behalf, so treat it like a password.

Creating a token

1. Open Settings from the user menu (top-right) and find the Personal access tokens section.
2. Click + New token, give it a name (e.g. “Local agent”), and pick its scopes (below).
3. Optionally set an expiry (30 / 90 / 365 days, or never).
4. Click Create token. The secret is shown once — copy it immediately; you won't be able to see it again. (If you lose it, revoke it and create a new one.)

You can hold up to 20 active tokens. To retire one, click Revoke next to it in the list — it stops working instantly, everywhere.

Scopes — what a token can do

Reading is implicit: any valid token can read whatever you can see — your own content and anything shared with your teams. The two read checkboxes (Read my private content, Read content shared with my teams) are there for clarity and don't restrict reads.

Writing is gated by scope. Grant only what the token needs:

• write:skills — create & edit skills
• write:agents — create & edit agents
• write:kits — create & edit kits

For safety, tokens can never spend on AI features (skill/agent AI generation, optimize, scan, simulate), manage billing, or mint/revoke other tokens — those stay browser-only. An unknown scope name is rejected when you create the token rather than silently ignored.

Using the REST API

Every action in the app is backed by a JSON API under /api. With a personal access token you can call it directly from scripts or your own agent. Send the token as a Bearer header:

# Who am I? (confirms the token works)
curl https://aiskillsbank.com/api/auth/me \
  -H "Authorization: Bearer skb_your_token_here"

# List your skills, agents, and kits (includes your private ones)
curl https://aiskillsbank.com/api/skills  -H "Authorization: Bearer skb_…"
curl https://aiskillsbank.com/api/agents  -H "Authorization: Bearer skb_…"
curl https://aiskillsbank.com/api/kits    -H "Authorization: Bearer skb_…"

# Create a skill (needs a token with the write:skills scope)
curl -X POST https://aiskillsbank.com/api/skills \
  -H "Authorization: Bearer skb_…" \
  -H "Content-Type: application/json" \
  -d '{"title":"My Skill","category":"Operations","content":"..."}'

Reads work with any valid token; writes require the matching write:* scope (a write without it returns 403). Content you can't see returns 404, exactly as it would in the browser.

MCP Integration

AI SkillsBank is also a Model Context Protocol (MCP) server, so MCP-compatible tools like Claude Desktop, Claude Code, Cursor, and Windsurf can connect to it natively — no copy-paste. It works two ways:

• Anonymous — connect with no credentials and reach the public library.
• Authenticated — present a personal access token and additionally reach your own private and team-shared skills, agents, and kits, and compile an agent's full system prompt.

Connecting

Point your MCP client at the endpoint below. To authenticate, configure your client to send an Authorization: Bearer skb_… header (most clients support a custom headers field on an HTTP/streamable MCP server):

Endpoint: https://aiskillsbank.com/mcp/
Header:   Authorization: Bearer skb_your_token_here

Important: include the trailing slash (/mcp/, not /mcp).

For step-by-step client setup (Claude Desktop, Claude Code, Cursor, Windsurf), see the MCP integration guide.

Available tools

Public (no token needed):

• search_skills — search the public library
• list_user_skills — a user's public skills
• get_skill — full skill details
• use_skill — render a skill with template variables filled in

Authenticated (with a token, on top of the above):

• whoami — confirm which account the token belongs to
• list_my_skills / list_my_agents / list_my_kits — your own content
• get_agent — an agent manifest plus its compiled system prompt
• get_kit — a kit and its member agents

The MCP surface is read-only — it never changes your data (writes stay on the API). As on the API, reads are implicit: a valid token reads whatever you can see, and the public read tools become private-aware once a token is presented.

Portfolio

Every user has a public portfolio page that showcases the public skills, agents, and kits they choose to feature. Open the Portfolio modal from your dashboard to pick which public items appear (only public items can be pinned), then share your portfolio link — visitors can drill from a kit into its agents and from an agent into its skills.