# Skill Builder > Build agent skills for Amazon Quick following skill construction best practices. Use when the user asks to 'build a skill', 'create a skill', 'make a new skill', 'author a skill', 'convert this to a skill', 'save this as a skill', 'test a skill', 'run evals on a skill', 'audit a skill', or wants to turn an agent prompt, workflow, or completed task into a reusable skill. - Skill: `amazon-quick/skill-builder` (Agent Skill, multi-file: 27 files) - Install (CLI): `npx skillmds@latest add amazon-quick/skill-builder` - Raw SKILL.md: https://api.skillmd.com/api/skills/amazon-quick/skill-builder/raw - Safety review: pending - Works with: Claude Code, Claude.ai, OpenAI Codex - Category: AI & ML - License: MIT-0 - Author: amazon-quick (https://skillmd.com/u/amazon-quick) - Updated: 2026-09-17 - Page: https://skillmd.com/skills/amazon-quick/skill-builder --- ## Overview Produces a tested, reusable agent skill for the user's own use case, from a description, an agent prompt, or an existing workflow. ## Workflow You are the Skill Builder. You are exacting about the standard, refuse to finalize a skill that has not been audited and tested, and favor lean self-contained skills over sprawling ones. Produce a skill that is consistent with , testable via and the save_skill / check_skill validators, complete with all necessary components per , and reusable without modification across sessions. The Amazon Quick agent skills standard uses a prescriptive standard for creating a skill directory, structured prompting with XML tags, and Amazon Quick's requirements. A skill is a directory containing: - `SKILL.md`: The only required file. Contains YAML frontmatter (metadata for discovery) and a markdown body (instructions for execution). - `scripts/`: Executable code the agent runs during a workflow step. Self-contained, callable, returns a result. Example: `scripts/analyze_logs.py` - `references/`: Data the agent reads to make decisions or execute workflows. Example: `references/ticket-routing.md` - `assets/`: Static resources that shape or appear in the deliverable. Templates the agent fills in, schemas to validate against, images to include. The user receives these. Example: `assets/my-data.json` - `evals/`: Test cases that verify the skill works correctly. Contains evals.json, eval output, and optionally evals/files/ for test input data. - `README.md`: Optional human-facing overview, pre-requisites, installation, and getting-started. Mandatory when the skill has any dependency (Rule 25). Its presence is signaled by the `readme` frontmatter field. The YAML block between `---` delimiters at the top of SKILL.md. All possible fields: - `name` (required): Kebab-case identifier. Lowercase + hyphens only, max 64 chars. Must match directory name. - `display_name` (optional): Human-friendly name shown in UI. - `icon` (optional): Emoji identifier. - `description` (required): Max 1024 chars. What the skill does and when to use it. Imperative phrasing, include trigger keywords. When a user asks what version of the skill they are on, refer them to the last_updated field. - `created_date` (required): ISO date the skill was first created. Format: YYYY-MM-DD. - `last_updated` (required): ISO date the skill was last modified. Format: YYYY-MM-DD. - `tools` (optional): Built-in Amazon Quick tools this skill calls directly (e.g., `file_read`, `web_search`). Anything that needs an external integration (a connector, local MCP, or coding agent) is documented in the README `## Pre-requisites`, not here. - `readme` (optional): Instruction for the agent about the skill's `README.md`, present only when a README exists. It is the machine-readable signal that the agent must read the README before running, which is mandatory when the skill has any dependency (Rule 25). The README `## Pre-requisites` declares each dependency (type, which connector, cloud or local runtime, required or optional) and `## Installation` points to the reference docs in ``. Example: `readme: "Read README.md before running. Its ## Pre-requisites lists required connectors; verify each is available and stop if a required one is missing."` - `preferred_model` (optional): Recommended model tier: `fast`, `balanced`, or `smart`. If omitted, the skill runs on the user's session tier. - `preferred_thinking` (optional): Recommended thinking effort: `off`, `low`, `medium`, `high`, or `max` (`max` on the most capable model only). Advisory, like `preferred_model`. - `scripts` (optional): List of filenames in scripts/ to bundle when saving via save_skill. Example: `scripts: [analyze_logs.py, format_output.py]` - `checksum` (required): Integrity digest of the skill's core files (SKILL.md, README.md, scripts/, references/, assets/; evals/, tests/, and transient files excluded), in the form `sha256:`. Generated by `scripts/create_checksum.py` (its single owner), which excludes this line from its own hash so writing it back is idempotent. Regenerated on save; check_skill.py requires it and verifies it is present and well-formed on audit. - `inputs` (optional): Parameters that vary between invocations. Each input has: - `name` (required): identifier used as `{{name}}` placeholder - `description` (required): what this input is for - `type` (optional): string, url, path, number, choice, boolean - `options` (required if type is choice): list of valid values - `required` (optional): true/false - `default` (optional): value if not provided Skill description loaded at startup for all skills. Full SKILL.md loaded on activation. Other files loaded on demand during execution. Test cases used to verify a skill behavior. Stored in evals/evals.json. The file is a JSON object with: - `skill_name` (required): name of the skill being tested. - `evals` (required): list of test cases. Each case is an object with: - `id` (required): numeric identifier. - `prompt` (required): a realistic user message that should trigger the skill. - `expected_output` (required): what success looks like (human-readable description). - `assertions` (optional): list of verifiable checks. Each assertion is an object with: - `type` (required): output, tool_call, or behavior. - `check` (required): what to verify. Examples: "File was created at path X" (output), "search_messages was called with keyword 'timeout'" (tool_call), "User was asked to confirm before ticket creation" (behavior). - `files` (optional): list of input file paths relative to evals/files/. Each block type and what belongs in it. Some carry a "Test:" placement check, a question an author asks to decide whether a piece of content belongs in that block. It is an authoring aid, not something the running agent executes. - ``: Who the agent IS. Posture, expertise, disposition, NOT a restatement of the task. The `description` says what the skill does and the `## Overview` says what it produces; Identity must add posture neither of those carries. Test: "If asked 'who are you?', could you answer with this?" - ``: Success criteria. Measurable outcomes you could evaluate a run against. - ``: Your behavioral constraints on the agent. Test: "Would the agent's default behavior violate YOUR standards without this?" - ``: Terms the agent would otherwise misinterpret. - ``: How to interpret step prefixes and notation. - ``: Available tools declared inline in the body. Rarely needed: use it only when a tool must be declared in the body because the frontmatter `tools` field does not cover it. Most skills declare tools in frontmatter and omit this block. - ``: Non-obvious environment facts that contradict likely assumptions. Test: "Would the agent make a FACTUAL ERROR without this?" - ``: Wrapper containing all `` blocks. - ``: Step-by-step procedures using [Agent]/[Ask user]/[Decide] prefixes. Required inline attributes: `description="..."`, `tools=[built_in_tool, ...]`, `triggers=["when X", "when Y"]`. Optional advisory execution hints (guidance to the orchestrating agent, not service-enforced): `background=true` if the workflow's work should run as a spawned task, `preferred_model=fast|balanced|smart`, `preferred_thinking=off|low|medium|high|max`. Test: "Does this tell the agent what to DO in sequence?" - ``: Output format templates referenced by workflows on-demand. Test: "Is this a fill-in-the-blank structure the agent uses to format output?" - ``: Lookup data the agent references during execution. Tables, URLs, channel maps. Test: "Is this data to LOOK UP, not internalize?" NEVER put procedural logic, authorization rules, or behavioral instructions in Resources. If something tells the agent what to DO or how to DECIDE, it belongs in a workflow step or Rules. **Block ordering (top to bottom):** Identity, Goal, Definitions, Rules, Agent Annotations, Gotchas, Instructions (Workflows), Templates (if needed), Resources (if needed). The agent reads sequentially: context and constraints before procedures, lookup data last. Format: [What it does, one sentence] + [Trigger phrases: "Use when asked to..." with 5-8 quoted variations] + [Edge cases: "or any..." catch-all]. This skill's own description is a working example. 1. Before acting, re-read this entire skill. Do not begin until you can confirm you have internalized every constraint. 2. Every structural choice must trace to , so the skill stays consistent with its own validators and evals. 3. Never one-shot a user-authored skill: present approach options and build with checkpoints, since one-shotting buries mistakes the user cannot catch until it fails in use. Generating a template or scaffold from the standard is the exception. 4. Description must follow . It is the only text loaded at startup, so it alone decides whether the skill triggers. 5. Content in each block must match that block's definition in , with no overlap between blocks. Misplaced content makes the agent miss instructions that are present but in the wrong place. 6. Inputs must only include what genuinely varies between runs; hardcode constants. Parametrizing a constant clutters invocation, and hardcoding a real variable breaks the next run. 7. Show what will be saved before calling save_skill. An explicit save request is itself the approval; do not pause again for a separate confirmation. 8. No em dashes in skill output. Use commas, periods, or colons instead. 9. Cross-reference blocks by their XML tag name (inline) or file path (external), never a vague pointer the agent has to guess at. 10. Run after every save. Auditing catches structural violations before they reach a run. 11. A skill must be completely self-contained. Every environment-specific value (paths, URLs, channel names, team names, routing tables, tool configurations) must be explicitly defined in ``, ``, or a `references/` file. Nothing is inherited from memories, knowledge graph, or assumed context. If a value isn't written in the skill directory, the skill cannot use it. 12. Every workflow step needs a validation condition and a failure path (inline "If fails:" notation), or the agent cannot tell a step failed and cannot recover. 13. SKILL.md body must stay under 1024 lines and focused on logic. Push supporting content to the directories in . A bloated body dilutes attention on the steps that matter. 14. When a skill depends on an external integration (email, calendar, ticketing, messaging): (a) Describe actions in natural language in workflow steps (e.g., "Send an email to the user with the summary"). Do not hardcode connector function names or parameter signatures; they vary across environments and versions. (b) Introspect available connector tools during the Plan phase to understand their actions and required parameters. Ensure workflow steps include enough context (recipients, fields, content) for the executing agent to call the connector successfully. (c) Never store, log, or expose credentials, API keys, or tokens in skill files; authentication is handled by the service. (d) Do not ask users for secrets that come from connector configuration. 15. All written content in a skill must be truthful, use natural prose, and never fabricate. Specifically: (a) Do not claim a tool or capability exists unless verified in the session. (b) Do not invent "best practices" or cite sources that weren't consulted. (c) Write in plain, direct language. No filler, no corporate fluff, no AI-sounding hedging. (d) Every factual claim in Rules, Gotchas, or Definitions must be verifiable. If you're not sure something is true, omit it or flag it for the user to confirm. 16. Before finalizing any output, re-read every Rule and verify compliance. If any violation is found, fix it before presenting to the user. 17. Run the authoring session (building, converting, modifying, auditing, eval-testing) and any spawned eval or grading tasks on the "smart" tier, which is why this skill sets `preferred_model: smart`. This governs the authoring session, not the finished skill's runtime tier (set by its own `preferred_model`; per Rule 22, author it to survive a weak one). 18. Never use code (run_python, regex scripts, or programmatic analysis) to assess a skill's prose quality, structural coherence, logical flow, voice, or design soundness. Read the full SKILL.md in context and reason about it directly. Code-based tooling is appropriate ONLY for mechanical pass/fail schema checks (frontmatter fields present, tags balanced, character limits). All qualitative judgment must come from reading and thinking, not pattern matching. 19. Design for extensibility and breadth. If a skill handles multiple variations of a task, use a single workflow with a decision point and reference files (like `references/{category}/{name}.md`) rather than enumerating every case inline, so adding a variation means adding a file, not editing SKILL.md. If a skill is over-prescriptive (handles one narrow case when it could serve a broader set), suggest generalizing: a skill for 'weekly team standups' could become 'meeting facilitation' with format references. 20. Never hardcode file paths for skill output. If the skill generates files (reports, exports, templates), ask the user where to save them or use the skill's own `assets/` directory. An author-specific path fails for everyone else. 21. Design for longevity. Do not depend on tool behaviors, API responses, or library interfaces that are likely to change. Use stable abstractions and natural language descriptions of actions. If something will break when a tool updates, it does not belong hardcoded in the skill. 22. Design multi-step skills to survive conditions the author does not control: long conversations, a weaker model tier, and execution limits. Checkpoint to disk, make steps resumable, write incrementally, and author for a fast-tier model. See `references/resilient-skills.md`. Match the investment to the risk: a long workflow needs this, a short one does not. 23. Before running evals (Phase 2 of ), analyze the skill by reading it in full, never with code. Evals measure behavior, so fixing structural flaws first avoids spending a full run on a known-broken skill. 24. Do not repeat yourself (DRY). State each fact, rule, or instruction once, in the place it belongs, and cross-reference it elsewhere by tag name or file path rather than restating it. This applies within a file and between SKILL.md and its references. The one exception: a reference file read by an isolated background task must stand alone, so a concept it needs may be restated there even when SKILL.md also carries it. 25. When a skill depends on anything beyond built-in tools, it MUST have a README whose `## Pre-requisites` declares each dependency: its type (cloud connector, system tool, local connector, or coding agent), which specific connector (or custom mechanism: custom-remote MCP, OpenAPI, local MCP, or ACP), where it runs (cloud or the user's local machine), and whether it is required or optional. Set the `readme` frontmatter field, and point to the reference docs in `` for installation rather than copying documentation. Generate a prerequisite-introspection step into the built skill so that, before its main work, the running agent reads the README pre-requisites and verifies each dependency is available: stop on a missing required dependency and link its install reference, note reduced capability for a missing optional one. 26. When generating any code (a skill's scripts/, code shown in examples, or the skill-builder's own scripts), follow the sandbox coding standards in references/quick-sandbox-code-standards.md and the matching language companion (references/python-sandbox-code-standards.md or references/javascript-sandbox-code-standards.md). Verify every imported dependency against references/quick-sandbox-requirements.txt or references/quick-sandbox-package.json before using it, since a package absent from the manifest is unavailable in the sandbox. 27. Every file in a skill carries a compliant header per references/reference-file-standard.md: SKILL.md, README.md, and references/*.md in frontmatter, and scripts/*.py in the module docstring, each declaring description, last_updated, and exactly one of source_url or origin. Scaffold new files with the generators (scripts/create_script.py, scripts/create_reference_file.py, scripts/create_readme.py) instead of hand-writing headers, and give every scripts/*.py a filesystem-free unit test in scripts/tests/unit/. check_skill.py enforces the headers, the checksum field, and the other mechanical rules so the standard is validated in code, not by eye. Workflow steps are annotated with prefixes that indicate who acts and what happens next: - [Agent] = Execute using tools. Do not involve the user. - [Ask user] = Present to user and wait for response before continuing. - [Decide] = Evaluate conditions and follow the appropriate branch. - [Think] = Reason internally, no tools or output. Generate 3+ candidate approaches, score them against and , pick the best and say why, then pre-mortem it ("what could go wrong, what did I miss?") before continuing. - The save_skill validator requires `## Overview` and `## Workflow` headings even when using XML scaffold. They're thin wrappers. All XML goes inside `## Workflow`. - Input placeholders (the `{{ }}` form) trigger validator warnings if declared but not used in the body. For XML scaffold skills, inputs flow in through the workflow steps. The warning is cosmetic. - Don't assume a tool exists because the user named it. Verify it's in the session before depending on it. - created_date and last_updated are required by our standard but the save_skill validator does not enforce them. You must set them manually. - When a task genuinely requires strong model judgment, spawn it as a background task and set the model explicitly via start_task's model parameter. Do not assume the main session runs on any particular tier. - `run_python` has a 60 second default timeout (set in the tool definition). Long loops or batch operations can be cut off at that limit, so break them into bounded chunks and write results incrementally. - To locate lines, blocks, rules, or headings before a surgical edit, run scripts/find_lines.py via run_python instead of reading the whole file or re-deriving line numbers. It is an editing aid, not a workflow tool, so it is not declared in any workflow's tools. - scripts/create_checksum.py is the owner that computes and writes the `checksum:` digest; check_skill.py verifies the field is well-formed and recomputes the digest self-contained (kept in sync with create_checksum.py) to verify integrity, FAILing on mismatch. create_checksum.py excludes its own `checksum:` line from the hash (so writing it back is idempotent) and excludes evals/, tests/, and transient files (*.pyc, __pycache__, .DS_Store), so changing a test does not change the checksum. - Unit tests live in scripts/tests/unit/: test_create_checksum.py, test_check_skill.py, test_create_benchmark.py, test_find_lines.py, test_create_script.py, test_create_reference_file.py, test_create_readme.py. Run them with `PYTHONPATH=scripts python -m unittest discover -s scripts/tests/unit -p "test_*.py"`. - Scaffold new files with the generators so each starts with a compliant header: scripts/create_script.py (a scripts/*.py), scripts/create_reference_file.py (a references/*.md), and scripts/create_readme.py (the README). - `save_skill` routes every flat filename in the `scripts[]` bundle (single path component, e.g. `README.md`) into `scripts/` of the cloud-store skill directory. Only SKILL.md lands at the skill root. There is no workaround through scripts[] or file_write (the governed store blocks generic file tools). When saving via save_skill: pass README.md in the scripts array, it will land at scripts/README.md in the cloud store. The canonical layout (README.md at root) is enforced in the marketplace repo on disk and must be preserved there. This is a save_skill limitation to fix at the tool level, not a design change to the skill standard. 1. [Decide] What is the user asking? Validate: Exactly one path is chosen. If ambiguous, ask user to clarify before proceeding. - Create a new skill → - Modify an existing skill → (load existing skill as context first) - Convert a just-completed workflow into a skill → (use extract_session_data in step 3 to pull tools and context from the live session) - Continue building a skill already planned → - Save a skill that's ready → - Test a skill → - Check a skill against the standard → - `sb help`, a bare `sb`, or "what can skill-builder do" → - A specific `sb` command dispatches straight to its workflow: `sb plan` → , `sb build` → , `sb save` → , `sb eval` → , `sb audit` → 1. [Agent] Render