---

name: writing-plans description: Use when you have a spec or requirements for a multi-step task, before touching code

Writing Plans

Overview

Write comprehensive implementation plans assuming the engineer has zero context for our codebase and questionable taste. Document everything they need to know: which files to touch for each task, code, testing, docs they might need to check, how to test it. Give them the whole plan as bite-sized tasks. DRY. YAGNI. TDD. Frequent commits.

Assume they are a skilled developer, but know almost nothing about our toolset or problem domain. Assume they don't know good test design very well.

Announce at start: "I'm using the writing-plans skill to create the implementation plan."

Context: This should be run in a dedicated worktree (created by brainstorming skill).

Save plans to: docs/plans/YYYY-MM-DD-<feature-name>.md

Bite-Sized Task Granularity

Each step is one action (2-5 minutes):

• "Write the failing test" - step
• "Run it to make sure it fails" - step
• "Implement the minimal code to make the test pass" - step
• "Run the tests and make sure they pass" - step
• "Commit" - step

Plan Document Header

Every plan MUST start with this header:

Copy# [Feature Name] Implementation Plan

> **For Claude:** REQUIRED SUB-SKILL: Use superpowers:executing-plans to implement this plan task-by-task.

**Goal:** [One sentence describing what this builds]

**Architecture:** [2-3 sentences about approach]

**Tech Stack:** [Key technologies/libraries]

---

Task Structure

Copy### Task N: [Component Name]

**Files:**
- Create: `AF.ECT.Server/Services/MyService.cs`
- Modify: `AF.ECT.Server/Program.cs:45-60`
- Test: `AF.ECT.Tests/Unit/MyServiceTests.cs`

**Step 1: Write the failing test**

```csharp
// ECTSystem Pattern: gRPC service test with InMemory database
[Fact]
public async Task MyMethod_WithInput_ReturnsExpected()
{
    // Arrange - Use InMemory database for tests
    var options = new DbContextOptionsBuilder<EctDbContext>()
        .UseInMemoryDatabase("test-db")
        .Options;
    
    using (var context = new EctDbContext(options))
    {
        context.SomeEntity.Add(new SomeEntity { Id = 1, Name = "test" });
        await context.SaveChangesAsync();

        var dataService = new MyDataService(context);
        var service = new MyServiceImpl(dataService);
        var mockContext = new Mock<ServerCallContext>();

        // Act
        var result = await service.MyMethodAsync(new MyRequest { Input = "test" }, mockContext.Object);

        // Assert
        Assert.NotNull(result);
        Assert.Equal("expected", result.Output);
    }
}

Step 2: Run test to verify it fails

Run: dotnet test AF.ECT.Tests --filter "FullyQualifiedName~MyMethod_WithInput_ReturnsExpected" --no-build -v minimal Expected: FAIL with "method not found" or "service not implemented"

Step 3: Write minimal implementation

Create file AF.ECT.Server/Services/MyService.cs:

Copynamespace AF.ECT.Server.Services;

public class MyServiceImpl : MyService.MyServiceBase
{
    public override async Task<MyResponse> MyMethodAsync(MyRequest request, ServerCallContext context)
    {
        return new MyResponse { Output = "expected" };
    }
}

Step 4: Run test to verify it passes

Run: dotnet test AF.ECT.Tests --filter "FullyQualifiedName~MyMethod_WithInput_ReturnsExpected" --no-build Expected: PASS

Step 5: Verify build succeeds with no warnings

Run: dotnet build ElectronicCaseTracking.sln /property:GenerateFullPaths=true /consoleloggerparameters:NoSummary Expected: Build succeeded with 0 errors, 0 warnings

Step 6: Commit

Copygit add AF.ECT.Server/Services/MyService.cs AF.ECT.Tests/Unit/MyServiceTests.cs
git commit -m "feat: add MyMethod to MyService"

Copy
## Remember
- Exact file paths always (use AF.ECT.* project structure)
- Complete code in plan (not "add validation")
- Exact commands with expected output (use `dotnet` CLI)
- Reference relevant skills with explicit SUB-SKILL markers
- DRY, YAGNI, TDD, frequent commits
- Test names follow xUnit pattern: `MethodUnderTest_Scenario_ExpectedResult`
- Reference ECTSystem conventions from `.github/copilot-instructions.md`

**C# .NET Specific for ECTSystem:**
- Use InMemoryDatabase for EF Core tests (not mocks)
- gRPC services: Test with ServerCallContext mock
- File-scoped namespaces: `namespace AF.ECT.Server.Services;` (no braces)
- Async patterns: Always use `async Task` with `await`
- Build verification: Include `dotnet build` step to catch warnings
- Tests in: `AF.ECT.Tests/Unit/`, `AF.ECT.Tests/Integration/`
- gRPC proto files: `AF.ECT.Shared/Protos/workflow.proto`
- Always test both success path AND exception path with RpcException

## Execution Handoff

After saving the plan, offer execution choice:

**"Plan complete and saved to `docs/plans/<filename>.md`. Two execution options:**

**1. Subagent-Driven (this session)** - I dispatch fresh subagent per task, review between tasks, fast iteration

**2. Parallel Session (separate)** - Open new session with executing-plans, batch execution with checkpoints

**Which approach?"**

**If Subagent-Driven chosen:**
- **REQUIRED SUB-SKILL:** Use superpowers:subagent-driven-development
- Stay in this session
- Fresh subagent per task + code review

**If Parallel Session chosen:**
- Guide them to open new session in worktree
- **REQUIRED SUB-SKILL:** New session uses superpowers:executing-plans