[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 ask user whether to skip.

Quick Summary

Goal: Autonomous feature implementation with structured discovery, knowledge graph, and approval gates (subagent variant of feature-implementation ).

MANDATORY IMPORTANT MUST Plan ToDo Task to READ the following project-specific reference doc:

project-structure-reference.md -- project patterns and structure

If file not found, search for: project documentation, coding standards, architecture docs.

Workflow:

Discovery & Analysis — Requirement decomposition, codebase investigation (grep patterns), pattern recognition
Knowledge Graph — Backend impact (Domain, Application, Persistence, API), Frontend impact (Components, State, Services, Routing)
Implementation Plan — Create external memory file .ai/workspace/analysis/{feature}-implementation.md with checklist
Approval Gate — Present plan (summary, files to create/modify, risks, questions), await user approval
Implementation — Backend layer-by-layer (Domain → Persistence → Application → API), then Frontend (API Service → Store → Components)
Verification — Backend, Frontend, Integration testing

Key Rules:

INVESTIGATE before implementing: Find similar features, identify patterns, map dependencies
External Memory: Track all decisions in analysis file with Evidence Log
Approval Required: CHECKPOINT before implementation - present plan and wait for user confirmation
Layer Order: Backend (Domain → Persistence → Application → API), Frontend (Service → Store → Components)

Be skeptical. Apply critical thinking, sequential thinking. Every claim needs traced proof.

Skill Variant: Use this skill for autonomous feature implementation with structured workflows. For interactive feature development with user feedback, use feature-implementation instead. For investigating existing features (READ-ONLY), use feature-investigation .

Feature Implementation Workflow

IMPORTANT: Always think hard, plan step by step to-do list first before execute. Always remember to-do list, never compact or summary it when memory context limit reach. Always preserve and carry your to-do list through every operation.

Prerequisites: ⚠️ MUST READ .claude/skills/shared/evidence-based-reasoning-protocol.md before executing.

Core Principles

INVESTIGATE before implementing
Follow established patterns in existing code
Use External Memory for complex features
Request user approval at checkpoint gates
Never assume - verify with code evidence

Phase 1: Discovery & Analysis

Step 1.1: Requirement Decomposition

Feature Analysis

Feature Name: [Name]
Business Objective: [What problem does this solve?]
Affected Services: [ServiceB, ServiceA, etc.]
Scope: [New entity? New command? UI change?]

Step 1.2: Codebase Investigation

Find related entities

grep -r "class.{RelatedConcept}" --include=".cs" services directory/

Find existing patterns

grep -r "{SimilarFeature}Command" --include="*.cs"

Check domain boundaries

grep -r "namespace.{ServiceName}.Domain" --include=".cs"

Find API endpoints

grep -r "[Route.{feature}]" --include=".cs"

Step 1.3: Pattern Recognition

Find similar features in codebase
Identify which patterns apply (CQRS, Event-driven, etc.)
Check for reusable components
Map dependencies

Phase 2: Knowledge Graph Construction

Backend Impact Analysis

Backend Changes Required

Domain Layer

New Entity: {EntityName}.cs
Entity Expressions: Static query expressions
Value Objects: {ValueObject}.cs

Application Layer

Commands: Save{Entity}Command.cs
Queries: Get{Entity}ListQuery.cs
Event Handlers: {Action}On{Event}EntityEventHandler.cs
DTOs: {Entity}Dto.cs

Persistence Layer

Entity Configuration: {Entity}EntityConfiguration.cs
Migrations: Add/Update schema

API Layer

Controller: {Entity}Controller.cs
Endpoints: POST/GET/PUT/DELETE

Frontend Impact Analysis

Frontend Changes Required

Components

List Component: {entity}-list.component.ts
Form Component: {entity}-form.component.ts
Detail Component: {entity}-detail.component.ts

State Management

Store: {entity}.store.ts
State Interface: {Entity}State

Services

API Service: {entity}-api.service.ts

Routing

Route definitions
Guards if needed

Phase 3: Implementation Plan

Create External Memory File

File: .ai/workspace/analysis/{feature-name}-implementation.md

Feature: {Feature Name}

Status: Planning

Implementation Order

Domain Layer (Entity, Expressions)
Persistence Layer (Configuration, Migration)
Application Layer (Commands, Queries, DTOs)
API Layer (Controller)
Frontend (Store, Components, Routing)

Checklist

Evidence Log

[Track all decisions and findings here]

Phase 4: Approval Gate

CHECKPOINT: Present plan to user before implementation

Implementation Proposal

Summary

[Brief description of what will be implemented]

Files to Create

{path/to/file1.cs} - Entity definition
{path/to/file2.cs} - Command handler
...

Files to Modify

{path/to/existing.cs} - Add new method
...

Risks & Considerations

[Risk 1]
[Risk 2]

Questions for Clarification

[Question 1]?
[Question 2]?

Ready to proceed?

Phase 5: Implementation

Backend Implementation Order

Domain Layer First

// 1. Create Entity public sealed class Feature : RootEntity<Feature, string> { public string Name { get; set; } = ""; // ... properties, expressions, validation }

Persistence Layer

// 2. Entity Configuration public class FeatureEntityConfiguration : IEntityTypeConfiguration<Feature> { public void Configure(EntityTypeBuilder<Feature> builder) { builder.ToTable("Features"); builder.HasKey(x => x.Id); // ... } }

// 3. Generate Migration // dotnet ef migrations add AddFeature

Application Layer

// 4. DTO (in EntityDtos/ folder) public class FeatureDto : EntityDtoBase<Feature, string> { } // project DTO base (see docs/backend-patterns-reference.md)

// 5. Command (Command + Handler + Result in ONE file) public sealed class SaveFeatureCommand : CqrsCommand<SaveFeatureCommandResult> { } // project CQRS command base

// 6. Query public sealed class GetFeatureListQuery : CqrsPagedQuery<GetFeatureListQueryResult, FeatureDto> { } // project CQRS query base

API Layer

// 7. Controller [ApiController] [Route("api/[controller]")] public class FeatureController : BaseController // project controller base (see docs/backend-patterns-reference.md) { [HttpPost] public async Task<IActionResult> Save([FromBody] SaveFeatureCommand cmd) => Ok(await Cqrs.SendAsync(cmd)); }

Frontend Implementation Order

API Service

@Injectable({ providedIn: 'root' }) export class FeatureApiService extends ApiServiceBase { // project API service base (see docs/frontend-patterns-reference.md) protected get apiUrl() { return environment.apiUrl + '/api/Feature'; } }

Store

@Injectable() export class FeatureStore extends project store base (search for: store base class)<FeatureState> { // State management }

Components

@Component({ selector: 'app-feature-list' }) export class FeatureListComponent extends project store component base (search for: store component base class)<FeatureState, FeatureStore> {}

Phase 6: Verification

Backend Verification

Entity compiles without errors
Migration applies successfully
Command handler saves entity correctly
Query returns expected data
API endpoint responds correctly

Frontend Verification

Store loads data correctly
Component renders without errors
Form validation works
CRUD operations complete

Integration Verification

End-to-end flow works
Error handling works
Authorization applied correctly

Anti-Patterns to AVOID

:x: Starting implementation without investigation

WRONG: Jump straight to coding

:x: Implementing multiple layers simultaneously

WRONG: Creating entity, command, and controller at once

:x: Skipping the approval gate

WRONG: Implementing large features without user confirmation

:x: Not following existing patterns

// WRONG: Creating custom patterns when platform patterns exist

Verification Checklist

Discovery phase completed with evidence
Knowledge graph documented
Implementation plan approved by user
Backend layers implemented in order
Frontend layers implemented in order
Integration tested
External memory file updated with progress

tasks-feature-implementation

Safety Notice

Copy this and send it to your AI assistant to learn