SKILL.md
graphql-schema-design
Schema design and review.
Proposes SDL in design mode and audits schema diffs in review mode, following the team's conventions.
$ dnx skillz add chillicream/agent-skills --skill graphql-schema-designAgentic coding
Consistently good code,
from any agent.
Agents are strong at filling a known pattern and weak at inventing architecture. The platform gives your agent the pattern to fill, your conventions as checked-in skills, and feedback it can act on before the merge, so what comes back is best-practice code.
$ dnx skillz add chillicream/agent-skillsOne command teaches your agent the platform.
Agent directory
Bring the agent you already use.
Every agent plugs into the platform the same two ways: skills teach it your conventions, MCP lets it call your API. Which agent you run is a preference; the quality of the code that comes back is the same.
Claude
Codex
Copilot
Cursor
Windsurf
Gemini
Cline- and many more
Review
Review stays fast because changes stay uniform.
Every change an agent produces on this platform is the same small, uniform shape, so review stays a glance instead of an investigation. That matters because writing code is cheap now; reviewing it is where your time actually goes.
feat: add product reviews3 files changed+73 -2In Review
Reviews/AddReview.cs+34-2Viewed
+[Mutation]
+static Task<Review> AddReviewAsync(...)
Reviews/ReviewAddedHandler.cs+21-0Viewed
+class ReviewAddedHandler : IEventHandler<ReviewAdded>
+ValueTask HandleAsync(ReviewAdded e, ...)
Reviews/GetSummaryHandler.cs+18-0Viewed
+class GetSummaryHandler : IQueryHandler<GetSummary, Summary>
+ValueTask<Summary> HandleAsync(...)
Checks
- BuildIn progress
- TestsIn progress
- Schema ChecksIn progress
Approve
time to ship
reviewed in seconds
Skills
Skills give your agent a head start.
Prototype a feature, derive the contract, evolve the schema: on this platform those are workflows an agent can run, not rituals a developer performs. Skills package that working knowledge so any agent starts productive, and your own conventions ship the same way, reviewed like code.
SKILL.md
prototype-feature
Frontend prototype with mock data.
Builds a clickable, local-only prototype with realistic mock data before any schema or backend work.
$ dnx skillz add chillicream/agent-skills --skill prototype-featureSKILL.md
prototype-to-contract
Prototype to backend contract.
Turns an accepted prototype into colocated GraphQL fragments and a contract for the backend.
$ dnx skillz add chillicream/agent-skills --skill prototype-to-contractOne pattern per problem.
Attributes mark queries, mutations, DataLoaders, and pagination; event handlers implement a single interface. The agent fills a known shape instead of inventing structure, so two features written weeks apart come back looking the same.
Query
[Query]Mutation
[Mutation]DataLoader
[DataLoader]Pagination
[UseConnection]Authorization
[Authorize]Filtering
[UseFiltering]Event handler
IEventHandlerRequest handler
IEventRequestHandlerFeedback before the merge.
A schema-first, strongly typed stack turns most bad edits into compile errors. nitro checks the rest in CI against the client registry, so a risky change comes back as feedback while the agent can still fix it.
agent patchremove Product.price
published opsProductCard { id name price }
feedbackbreaking: published clients affected
agent fixdeprecate Product.price instead
At runtime
Your API is a tool, too.
The same server that shapes the code agents write also serves them at runtime. AddMcp() and MapGraphQLMcp() expose your operations as MCP tools at /graphql/mcp, so an agent can query the running API while it works instead of guessing at your data.
Tool exposure
getProductidempotent
searchOrdersidempotent
createReviewdestructive
Point your agent at the platform.
The patterns, the feedback, and the checks are already in place; whatever agent your team uses writes against them. One command installs the helpers, and your conventions ride along the same way.
$ dnx skillz add chillicream/agent-skills