Canonical skill for initializing and maintaining projects following the APP (AI-First Programming Paradigm) protocol.
Install
mkdir -p .claude/skills/app && curl -L -o skill.zip "https://agentskills.codes/api/skills/download/10761" && unzip -o skill.zip -d .claude/skills/app && rm skill.zipInstalls to .claude/skills/app
Activation
This is the description your AI agent reads to decide when to run this skill — the better it matches your request, the more reliably it fires.
use when setting up APP projects, adding host apps, creating or updating Cases, introducing packages, classifying shared code across cases/packages/core/shared, maintaining case .us.md artifacts, validating APP grammar, reviewing structural drift, and adapting existing projects incrementally with the canonical /app workflowKey capabilities
- →Inspect project topology and classify artifacts
- →Set up new APP projects with canonical layers
- →Add host apps like backend, portal, or agent
- →Create and update Case artifacts
- →Validate APP grammar and host runtime rules
- →Detect architectural drift in Cases and hosts
How it works
The skill enforces a strict operational profile by guiding the agent through an inspect, specify, create, validate, and review workflow. It requires the presence of a spec.md file to serve as the normative protocol reference.
Inputs & outputs
When to use app
- →Setup new APP project
- →Create new host app
- →Validate architectural grammar
About this skill
/app — Canonical Operational Skill for APP
This is the active PRD revision of the canonical /app skill.
It keeps the operational content of the previous revision while reducing repetition
and improving scanability.
Revision Metadata
- Version:
1.1.6-prd - Protocol:
[email protected] - Status:
prd
What This Skill Does
- inspect an APP project and explain its topology
- set up a new APP project with canonical layers and the first host app
- add a new host app such as
backend,portal,agent,worker, orlambdas - create a new Case such as
usuario_criar - implement or revise
domain,api,ui,web,mobile,stream, andagenticsurfaces - introduce
packages/and expose them correctly through host registries - classify whether a new artifact belongs in
cases/,packages/,core/shared/, or requires protocol evolution - validate APP grammar and host runtime rules
- detect architectural drift in Cases and hosts
- adapt an existing project to APP incrementally when requested
- create or update
<case>.us.mdwhen semantics, contracts, or composition change
If you do not know APP yet, this skill should guide you through the canonical workflow instead of assuming prior protocol knowledge.
APP is the protocol layer of the AI-First Programming Paradigm.
/app is the canonical skill for applying that protocol in real projects.
Example Prompts
Use /app to inspect this repository.Set up a new APP project using /app.Add an agent host app using /app.Create case usuario_criar using /app.Introduce packages/ for shared HTTP clients using /app.Adapt this existing project to APP incrementally using /app.Implement the api surface for usuario_criar using /app.Validate this repository with APP grammar.Review drift in this project using /app.Create usuario_criar with domain, api, and usuario_criar.us.md.
1. Identity
Positioning
- executable workflow for APP engineering
- architecture-aware implementation and review guide
- operational lint for APP grammar and runtime rules
Scope
- operates with the adjacent installed
spec.mdas its normative protocol reference - operationalizes the current APP protocol version
- may be stricter than baseline APP conformance
- must not contradict canonical APP grammar
Authority
- for the agent: this document is the operational source of truth
- for project maintenance: protocol changes must be reflected here
- if implementation drifts from this document, report the drift and keep following this grammar until a human resolves it
2. /app Profile
APP defines baseline protocol grammar.
/app defines a stricter operational profile for agents working on APP projects.
| Topic | APP baseline | /app profile |
|---|---|---|
test() | strongly recommended | required on every surface created or edited by the agent |
<case>.us.md | optional support artifact | required for new Cases, new surfaces, and semantic changes |
| workflow | free | inspect → specify → create/implement → validate → review |
| validation | may be partial | must happen before task closure |
| agentic completeness | agentic optional; app-level agentic host formalized in current spec | when the task requires agentic at Case or app level, the full formal definition is mandatory; partial or placeholder agentic layers are non-conformant in /app |
| subagents | outside protocol scope | required when supported and parallel work is useful |
Core Rules
- start unknown work with
inspect - on every
/appturn, read thisSKILL.mdand the adjacent installedspec.mdbefore acting; ifspec.mdis missing, report incomplete skill installation or drift - keep
handler()thin and free of business logic - create or update
<case>.us.mdwhen semantics change - add or update
test()on every touched surface - if the task requires the agentic layer, define it completely according to the current normative contract; never leave a partial agentic host or surface behind
- validate and review before closing the task
3. APP Model
Canonical Layers
packages/ → core/ → cases/ → apps/
| Layer | Role |
|---|---|
packages/ | shared project code exposed by the host through ctx.packages |
core/ | protocol contracts, base classes, types, integration interfaces |
cases/ | capabilities; shareable business logic lives here |
apps/ | hosts; select Cases, providers, packages, runtime, and deployment model |
Import Rules
| Relationship | Rule |
|---|---|
cases/ → core/ | allowed |
apps/ → cases/ | allowed through registry |
apps/ → packages/ | allowed |
cases/ → packages/ direct import | forbidden; use ctx.packages |
| Case A → Case B direct import | forbidden; use ctx.cases |
cases/ → apps/ | forbidden |
Structural Tasks Supported by /app
| Task | Canonical result |
|---|---|
| new APP project | create canonical layers, first host app, first registry, and first Case path |
| new host app | add apps/<app>/app.ts and apps/<app>/registry.ts with only needed _cases, _providers, _packages |
| new package | add shared project code under packages/ and expose it per app through _packages / ctx.packages |
new core/shared/ artifact | add only if it is a protocol-level contract or shared structural shape |
| new canonical surface | stop normal implementation flow and treat as protocol evolution |
| existing-project adoption | carve out APP-managed areas incrementally; do not force a full rewrite unless requested |
4. Case Model
A Case is one cohesive capability organized inside its own folder.
Naming and Layout
- canonical name:
<entity>_<verb> - folder:
cases/<domain>/<case>/ - surface file:
<case>.<surface>.case.<ext> - support artifact:
<case>.us.md
<case>.us.md
The canonical support artifact is <case>.us.md.
It records operational intent without replacing domain.case.ts.
Required in /app when:
- a new Case is created
- a new surface is added
- Case semantics change
- cross-case composition is introduced
- recovery, policy, or agentic contract changes materially
Optional only when:
- the change is purely editorial
- the change is purely technical and does not alter semantics, contracts, or behavior
5. Surface Grammar
Implement only the surfaces the task needs.
5.1 Summary Matrix
| Surface | File | Goal | Required in /app | Optional | Key Rules |
|---|---|---|---|---|---|
domain | <case>.domain.case.ts | pure semantics, invariants, validation, schemas, examples | caseName(), description(), inputSchema(), outputSchema(), test() | validate, invariants, valueObjects, enums, examples, definition | no I/O; consumed manually by other su |
Content truncated.
When not to use it
- →When the project does not follow the canonical APP protocol
- →When the task involves partial or placeholder agentic layers
Prerequisites
Limitations
- →Requires test() on every surface created or edited
- →Must not contradict canonical APP grammar
- →Partial agentic layers are non-conformant
How it compares
Unlike manual project management, this skill enforces a specific grammar and requires test creation for every surface touched.
Compared to similar skills
app side by side with the closest alternatives in the catalog.
| Skill | Installs | Updated | Safety | Difficulty |
|---|---|---|---|---|
| app (this skill) | 0 | 4mo | No flags | Intermediate |
| agent-pseudocode | 1 | 6mo | No flags | Intermediate |
| phase-2-convention | 0 | 4mo | Review | Beginner |
| phase-1-schema | 0 | 5mo | No flags | Beginner |
Try saying
Example prompts that trigger this skill in your AI assistant.
You might also like
agent-pseudocode
ruvnet
Agent skill for pseudocode - invoke with $agent-pseudocode
phase-2-convention
LowyShin
|
phase-1-schema
cdman28
|
writing-plans
AntonyKervazoCanut
Convert a spec or requirement into a numbered, executable implementation plan
software-architecture
davila7
Guide for quality focused software architecture. This skill should be used when users want to write code, design architecture, analyze code, in any case that relates to software development.
codex
Lucklyric
Invoke Codex CLI for complex coding tasks requiring high reasoning capabilities. This skill should be invoked when users explicitly mention "Codex", request complex implementation challenges, advanced reasoning, or need high-reasoning model assistance. Automatically triggers on codex-related requests and supports session continuation for iterative development.