EasyPlatform create-feature

[Implementation] Scaffold a new feature with backend and frontend components

install

source · Clone the upstream repo

git clone https://github.com/duc01226/EasyPlatform

Claude Code · Install into ~/.claude/skills/

T=$(mktemp -d) && git clone --depth=1 https://github.com/duc01226/EasyPlatform "$T" && mkdir -p ~/.claude/skills && cp -r "$T/.claude/skills/create-feature" ~/.claude/skills/duc01226-easyplatform-create-feature && rm -rf "$T"

manifest: .claude/skills/create-feature/SKILL.md

source content

[IMPORTANT] Use
TaskCreate
to break ALL work into small tasks BEFORE starting — including tasks for each file read. This prevents context loss from long files. For simple tasks, AI MUST ATTENTION ask user whether to skip.

Critical Thinking Mindset — Apply critical thinking, sequential thinking. Every claim needs traced proof, confidence >80% to act. Anti-hallucination: Never present guess as fact — cite sources for every claim, admit uncertainty freely, self-check output for errors, cross-reference independently, stay skeptical of own confidence — certainty without evidence root of all hallucination.

AI Mistake Prevention — Failure modes to avoid on every task:

Check downstream references before deleting. Deleting components causes documentation and code staleness cascades. Map all referencing files before removal.

Verify AI-generated content against actual code. AI hallucinates APIs, class names, and method signatures. Always grep to confirm existence before documenting or referencing.

Trace full dependency chain after edits. Changing a definition misses downstream variables and consumers derived from it. Always trace the full chain.

Trace ALL code paths when verifying correctness. Confirming code exists is not confirming it executes. Always trace early exits, error branches, and conditional skips — not just happy path.

When debugging, ask "whose responsibility?" before fixing. Trace whether bug is in caller (wrong data) or callee (wrong handling). Fix at responsible layer — never patch symptom site.

Assume existing values are intentional — ask WHY before changing. Before changing any constant, limit, flag, or pattern: read comments, check git blame, examine surrounding code.

Verify ALL affected outputs, not just the first. Changes touching multiple stacks require verifying EVERY output. One green check is not all green checks.

Holistic-first debugging — resist nearest-attention trap. When investigating any failure, list EVERY precondition first (config, env vars, DB names, endpoints, DI registrations, data preconditions), then verify each against evidence before forming any code-layer hypothesis.

Surgical changes — apply the diff test. Bug fix: every changed line must trace directly to the bug. Don't restyle or improve adjacent code. Enhancement task: implement improvements AND announce them explicitly.

Surface ambiguity before coding — don't pick silently. If request has multiple interpretations, present each with effort estimate and ask. Never assume all-records, file-based, or more complex path.

Prerequisites: MUST ATTENTION READ before executing:

Understand Code First — HARD-GATE: Do NOT write, plan, or fix until you READ existing code.
Search 3+ similar patterns (
grep
/
glob
) — cite
file:line
evidence
Read existing files in target area — understand structure, base classes, conventions
Run
python .claude/scripts/code_graph trace <file> --direction both --json
when
.code-graph/graph.db
exists
Map dependencies via
connections
or
callers_of
— know what depends on your target
Write investigation to
.ai/workspace/analysis/
for non-trivial tasks (3+ files)
Re-read analysis file before implementing — never work from memory alone

NEVER invent new patterns when existing ones work — match exactly or document deviation
BLOCKED until:
- [ ]
Read target files
- [ ]
Grep 3+ patterns
- [ ]
Graph trace (if graph.db exists)
- [ ]
Assumptions verified with evidence

Quick Summary

Goal: Scaffold a new full-stack feature with backend (entities, CQRS, controllers) and frontend (Angular components, services).

Workflow:

Analyze — Break down requirements, identify scope (backend/frontend/full-stack)
Identify — Determine target microservice and Angular app/module
Plan — Map out entities, commands/queries, endpoints, components, DTOs
Approve — Present plan, wait for explicit user approval before creating files
Create — Scaffold files in order: entities → application → DTOs → controllers → frontend

Key Rules:

DO NOT proceed without explicit user approval
Follow platform patterns from CLAUDE.md and
```
.github/prompts/
```
templates
Build order: Domain → Application → API → Frontend
Verify with
```
dotnet build
```
and
```
nx build
```
after creation

Be skeptical. Apply critical thinking, sequential thinking. Every claim needs traced proof, confidence percentages (Idea should be more than 80%).

Create a new feature: $ARGUMENTS

Steps:

Analyze Requirements
- Break down the feature requirements
- Identify the scope (backend only, frontend only, or full-stack)
Identify Service Location
- Determine the appropriate microservice for backend
- Identify the Angular app/module for frontend
Plan Implementation
- Domain entities needed
- CQRS Commands/Queries
- API endpoints (controllers)
- Angular components and services
- DTOs and validation

Use Project Patterns

Reference patterns from CLAUDE.md

Use

.github/prompts/

templates for scaffolding:

```
create-cqrs-command.prompt.md
```
```
create-cqrs-query.prompt.md
```
```
create-entity-event.prompt.md
```
```
create-angular-component.prompt.md
```
```
create-api-service.prompt.md
```

Wait for Approval
- Present the implementation plan
- DO NOT proceed without explicit approval
Create Files (After Approval) Execute in this order:
1. Domain entities (
```
.Domain/Entities/
```
  )
2. Application layer (
```
.Application/UseCaseCommands/
```
  ,
```
.Application/UseCaseQueries/
```
  )
3. Entity DTOs (
```
.Application/EntityDtos/
```
  )
4. API controllers (
```
.Api/Controllers/
```
  )
5. Frontend components and services
Verify
- Build backend:
```
dotnet build
```
- Build frontend:
```
nx build <app-name>
```

Closing Reminders

MANDATORY IMPORTANT MUST ATTENTION break work into small todo tasks using
```
TaskCreate
```
BEFORE starting
MANDATORY IMPORTANT MUST ATTENTION search codebase for 3+ similar patterns before creating new code
MANDATORY IMPORTANT MUST ATTENTION cite
```
file:line
```
evidence for every claim (confidence >80% to act)
MANDATORY IMPORTANT MUST ATTENTION add a final review todo task to verify work quality
MANDATORY IMPORTANT MUST ATTENTION validate decisions with user via
```
AskUserQuestion
```
— never auto-decide MANDATORY IMPORTANT MUST ATTENTION READ the following files before starting:
MANDATORY IMPORTANT MUST ATTENTION search 3+ existing patterns and read code BEFORE any modification. Run graph trace when graph.db exists.
MUST ATTENTION apply critical thinking — every claim needs traced proof, confidence >80% to act. Anti-hallucination: never present guess as fact.
MUST ATTENTION apply AI mistake prevention — holistic-first debugging, fix at responsible layer, surface ambiguity before coding, re-read files after compaction.