Turn a fuzzy AI idea into a designed system, working implementation, repeatable evaluation, and a publishable asset.
This category is strongest when the work stops being “just write me a prompt” and turns into AI agent architecture, prompt engineering, tooling, evaluation, or reusable system design. It gives you a path from messy requirements to build-ready artifacts and public-facing documentation without treating those as disconnected tasks.
skill improvement infrastructure now lives in the sibling skill_lab category. agent_builder is for building, implementing, evaluating, extending, and showcasing agent systems themselves.
Copy one of these prompts:
Use $hwamony-requirements-clarifier to figure out what I actually need from this vague project request before we plan anything.Use $hwamony-agent-system-builder to compare 3 architectures for this support copilot and tell me which one is easiest to ship first.Use $hwamony-prompt-architect to turn this fragile prompt into a schema-first prompt system with tool and failure rules.Use $hwamony-agent-system-evaluator to create a rubric and run log format for this agent before we iterate again.Use $hwamony-skill-showcase to rewrite this internal skill so GitHub visitors instantly understand it and search-friendly metadata is ready to ship.
- building a new agent or assistant from requirements
- deciding whether a task should stay single-prompt or become a workflow
- implementing provider-aware runtime code after the architecture is chosen
- evaluating whether a built system is actually getting better
- packaging a good internal skill so other people can understand and reuse it
- finding external skills that can extend your toolkit
- it covers the full loop from ambiguity to implementation to evaluation to public packaging
- it treats prompts, architecture, and history strategy as system decisions rather than isolated wording tasks
- it includes both build-side skills and publish-side skills, so strong internal work does not stay trapped inside the repo
- it gives visitors a readable path instead of a flat pile of AI engineering folders
Designs an AI agent or single-model system from requirements through decision-making.
Use this when you want to:
- clarify requirements
- write a task brief
- compare architecture options
- define message-history strategy
- prepare a clean implementation handoff
Clarifies ambiguous user requests into actionable briefs through focused questions, proposed interpretations, and working-brief summaries.
Use this when you want to:
- turn a vague ask into a concrete deliverable
- uncover hidden assumptions and non-goals
- ask better clarification questions instead of broad questionnaires
- identify what the user really wants before planning or implementation
Implements the selected system architecture.
Use this when you want help creating:
- prompts
- configs
- runtime code
- history adapters
- provider-aware implementation structure
Evaluates and iterates on a built system.
Use this when you want:
- test planning
- run logging
- rubric-based scoring
- evaluation summaries
- a tighter feedback loop for the next iteration
Designs prompts as reusable systems with routing, schemas, tools, and production constraints.
Use this when you need:
- a new prompt
- a prompt critique
- model or vendor routing guidance
- tool-aware prompt design
- a production-minded prompt system rather than a one-off string
Searches GitHub for relevant agent skills and helps install the best match.
Use this when you want to:
- browse existing skills
- compare installable options
- find a skill for a specific framework or workflow
- install a promising skill from GitHub
Transforms internal skills into public-facing showcases with SEO-friendly README copy, sharper examples, repository metadata, and launch-ready copy.
Use this when you want to:
- rewrite a README for humans instead of internal use only
- improve GitHub discoverability with clearer descriptions, topics, and first-screen wording
- clarify who the skill is for and when to use it
- generate example prompts and demo ideas
- prepare GitHub descriptions, topics, or launch copy
- turn a private-looking skill into a showcase-ready open source asset
- turning fuzzy AI ideas into structured projects
- turning ambiguous asks into actionable briefs before the project starts
- reducing architecture guesswork
- building reusable systems instead of one-off experiments
- connecting design, implementation, and evaluation into one loop
- evaluating agent systems and hardening prompt systems
- helping strong internal skills look legible and valuable from the outside
- deciding when to stay inside
agent_builderversus when to move intoskill_labfor skill-level improvement loops
- AI engineers
- prompt engineers
- tool builders
- workflow designers
- teams building internal assistants or production agents
If you are new to this folder, a simple path is:
- start with
hwamony-requirements-clarifierwhen the ask is still fuzzy - move to
hwamony-agent-system-builderonce the brief is actionable - move to
hwamony-agent-system-implementer - use
hwamony-agent-system-evaluatorafter implementation exists - use the
skill_labcategory when you want to evaluate and improve the skills themselves
Use hwamony-prompt-architect whenever prompt design becomes central, hwamony-search-skills when you want to extend your toolkit with external skills, and hwamony-skill-showcase when the work shifts from building the skill to publishing it well.
SKILL.mdand this README are shared underCC BY 4.0- any original code inside nested
scripts/directories is shared under the MIT License
See the repository root LICENSE files for details.