work-on-milestone

Use this skill when asked to work on a milestone.You are not required to complete the milestone when this skill is invoked.

⭐6stars🔀0forks📁View on GitHub🕐Updated Jan 4, 2026⬇️2downloads

When & Why to Use This Skill

The 'work-on-milestone' Claude skill is a comprehensive workflow designed for systematic software development and project tracking. It enables AI agents to handle complex coding milestones by following a strict protocol: reviewing recent changes, executing test-driven development (TDD), and managing cross-language dependencies between C and Go. By emphasizing host interface assessment and iterative implementation loops, it ensures high-quality code contributions and project stability while maintaining clear progress tracking.

Use Cases

  • Executing complex software milestones: Use this skill to guide the AI through multi-step feature development while maintaining architectural integrity and project standards.
  • Test-Driven Development (TDD) workflows: Automate the process of identifying functional gaps, implementing fixes across different language layers, and verifying results through rigorous testing.
  • Standardizing development SOPs: Ensure the agent follows specific project protocols, such as memory management rules, host interface checks, and detailed commit message formatting during the development lifecycle.
namework-on-milestone
description|

Working Through a Milestone

Before Starting

  1. Review the last commit: git show HEAD
  2. Run tests to see current state: mise test
  3. Read relevant test files in testcases/ to understand expected behavior
  4. CRITICAL: Assess host interface sufficiency
    • Review src/tclc.h (TclHostOps) to understand available primitives
    • Determine if the feature can be implemented using existing ops
    • If TclHostOps needs to be extended: STOP IMMEDIATELY and inform the user
    • Do not proceed until you have received explicit approval and direction

Implementation Loop

For each failing test:

  1. Identify what's missing - parse test output to understand the gap
  2. C interpreter changes (in src/):
    • Create new builtin_*.c file if adding a command
    • Add declarations to internal.h
    • Register command in interp.c builtins table
    • Implement using TclHostOps primitives only
  3. Go host changes (in interp/):
    • Implement callbacks in callbacks.go
    • Add state to Interp struct in tclc.go if needed
    • Follow shimmering rules in interp/CLAUDE.md
  4. Run tests: mise test
  5. Iterate until tests pass

Key Patterns

  • List operations mutate: Use ops->list.from() to copy before iterating
  • String lengths: Count carefully, don't include null terminator
  • Shimmering: Use Get*() methods in Go for type conversion, never access Object fields directly
  • Error messages: Match TCL's exact format (check test expectations)

After All Tests Pass

  1. Run tests multiple times to verify stability
  2. Commit with detailed message explaining:
    • What was implemented
    • Key implementation details
    • Important learnings for future work
  3. Use the format from CLAUDE.md (heredoc, co-author line)

File Checklist for New Commands

  • src/builtin_<cmd>.c - implementation
  • src/internal.h - declaration
  • src/interp.c - registration
  • interp/callbacks.go - host callbacks (if new ops needed)
  • interp/tclc.go - state/structs (if needed)