skills.rest
deMGoncalves
deMGoncalvesCOMMUNITY
Explore all skills by this author →
WebsiteGitHub

Developer Skill

Implement code tasks atomically with DDD tactical patterns and TDD.

4|1|Updated Oct 8, 2025
Search Tags:#TDD#software development#clean code#DDD#AI coding#code implementation#task-based development
One-click install
npx skills add https://github.com/deMGoncalves/arq-specs-template --skill developer-skill
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: Developer Skill
Source: https://github.com/deMGoncalves/arq-specs-template/tree/main/.claude/skills/developer
Command: npx skills add https://github.com/deMGoncalves/arq-specs-template --skill developer-skill

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill requires uuid.

What problem does it solve?

This Skill guides AI in implementing code one small task at a time, preventing common AI hallucinations that occur when processing large, complex specifications. It ensures deterministic, correct code by focusing on minimal context and strict adherence to acceptance criteria.

Core Features & Use Cases

  • Atomic Task Implementation: Breaks down development into small, manageable tasks, each with a precisely defined, limited context (~500 lines) to maintain AI focus.
  • Test-First Development (TDD): Enforces a strict RED → GREEN → REFACTOR cycle, ensuring that tests are written before implementation and that all code is thoroughly verified.
  • Domain-Driven Design (DDD) Adherence: Guides the implementation of DDD tactical patterns (Aggregates, Value Objects, Entities, Domain Events) with a Co-Located directory structure and semantic naming.
  • Use Case: When implementing a new feature, this Skill ensures you tackle it task-by-task, writing tests first, then the code, and refactoring, all while adhering to DDD principles. This structured approach guarantees high-quality, maintainable code.

Quick Start

After the Orchestrator provides tasks.md, start with the first task (e.g., TASK-001). Load ONLY the context specified in that task. Example for TASK-003: Implement factory criar-usuario.ts.

Frequently Asked Questions about Developer Skill

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I implement code tasks without AI hallucinations?▼

Task-by-task implementation prevents hallucinations by loading only ~500 lines of context per task, enforcing strict acceptance criteria, and applying atomic, testable units aligned with DDD patterns. This focused scope maintains AI accuracy throughout development.

What is test-driven development and why does it matter for code quality?▼

Test-driven development (TDD) enforces a RED → GREEN → REFACTOR cycle where tests are written before implementation. This ensures all code is thoroughly verified, catches defects early, and produces maintainable, high-quality implementations.

How do I structure code using Domain-Driven Design principles?▼

Domain-Driven Design uses tactical patterns—Aggregates, Value Objects, Entities, Domain Events—organized in a co-located directory structure: src/[bounded-context]/[container]/[component]. Semantic naming and this layout keep domain logic cohesive and testable.

Can I use task-based development with SOLID principles and Object Calisthenics?▼

Yes. Task-based development integrates SOLID principles, Object Calisthenics, linting, and continuous documentation within each atomic task. This ensures code adheres to multiple quality standards without overwhelming context.

What's the best way to prevent scope creep during feature implementation?▼

Breaking features into small, precisely defined tasks with limited context (~500 lines) and explicit acceptance criteria naturally prevents scope creep. Each task focuses on one atomic unit, ensuring deterministic, correct code delivery.

Do I need prior DDD knowledge to use task-based development?▼

While DDD familiarity helps, task-based development guides you through DDD tactical patterns step-by-step. The structured, phase-based workflow with explicit domain patterns makes DDD practical for teams new to domain-driven approaches.

Related Skills

Explore More Software Engineering Skills→
deMGoncalvesdeMGoncalves
4

orchestrator

Decompose large specifications into atomic tasks with dependencies and acceptance criteria.

Community
Advanced
mcj-codermcj-coder
1

local-dev-experience

Configure hot reload, incremental builds, and test filtering for local development environments.

Community
Intermediate
joseph-c-mcguirejoseph-c-mcguire
1

06-tech-tooling

Set up and validate linters, formatters, and test runners for CI builds.

Community
Advanced
bjorkgardbjorkgard

V3 DDD Architecture

Decompose monolithic code into modular DDD bounded contexts.

Community
Advanced