Skip to content
maenifold
GitHub

Agentic SLC (Simple, Lovable, Complete)

11 steps

AI agent-assisted development using Simple, Lovable, Complete principles with anti-slop controls

Triggers

agentic slcsimple lovable completeslc agileai agent developmentslc methodologyanti-slop developmentagentic product developmentsimple complete lovableagent assisted slcslick development

Steps

  1. 1.

    📋 Adopt Role

    FIRST STEP: Adopt the engineer role and white color

    Effort:low
    Guardrails
    • scope_limit: Role adoption only, no implementation
  2. 2.

    📋 Define Clear Requirements

    FIRST: Read and restate the specifications EXACTLY as provided. If ANY ambiguity or uncertainty exists, STOP IMMEDIATELY with:

    1. Clear explanation of what is ambiguous
    2. Recommendation: "Dispatch new agent with clarified instructions on: [specific unclear points]"
    3. Do NOT proceed with guesses - failing fast is better than building wrong solutions.

    Create unambiguous user stories with specific acceptance criteria. Challenge every assumption about user needs.

    🧠 USE SEQUENTIAL THINKING TOOL: Use the SequentialThinking tool to work through this systematically:

    What specific, measurable criteria define success? What assumptions am I making that could lead to over-engineering?

    Based on architecture analysis:

    • What dependencies must be integrated? (serana find_all_references)
    • What patterns are established? (SearchMemories + serana symbol_search)
    • What existing infrastructure should be used? (serana hover for signatures)
    • What related concepts exist in knowledge graph? (BuildContext)
    Enhanced Thinking
    Tools:SequentialThinking*SearchMemoriesBuildContextContext7
    Effort:high
    Guardrails
    • prevent_overengineering: Challenge every assumption
    • measurable_criteria: All success criteria must be testable
    • escape_hatch: STOP if unclear - explain ambiguity and recommend re-dispatch with clarification
    • spec_restatement: Must restate specs exactly before proceeding
    • fail_communication: When stopping, must explain why and suggest specific clarifications needed
  3. 3.

    🔎 Research & Knowledge Review

    Before planning or implementation, systematically search for relevant prior knowledge and conduct research.

    🧠 USE SEQUENTIAL THINKING TOOL: Use the SequentialThinking tool to work through this systematically:

    1. Use SearchMemories to find relevant prior knowledge and avoid duplication
    2. Use BuildContext to understand concept relationships in knowledge graph
    3. Use RecentActivity to see related recent work
    4. Conduct online research (WebSearch/Context7) for additional insights as needed
    5. Save new findings using WriteMemory with proper formatting

    When saving research, you MUST:

    • Use descriptive titles with [[Wiki Links]] to connect related entities
    • Include YAML frontmatter and proper formatting
    • Tag appropriately and organize in folders for discoverability
    • Connect new research to existing knowledge graph
    Enhanced Thinking
    Tools:SequentialThinking*SearchMemories*BuildContextRecentActivityWriteMemory*WebSearchContext7
    Effort:high
    Guardrails
    • avoid_duplication: Check existing memory before researching
    • proper_format: Must use Wiki Links and YAML frontmatter
    • knowledge_connection: Connect to existing concepts
  4. 4.

    🚪 Quality Gate: Requirements Validation

    Validate requirements are clear, testable, and prevent AI over-engineering.

    🧠 ENHANCED THINKING REQUIRED: Use the SequentialThinking tool and context7 to work through this systematically.

    Can AI misinterpret these requirements? Are success criteria measurable? Do requirements prevent unnecessary complexity?

    🚨 ESCAPE HATCH: If requirements are ambiguous or could be misinterpreted:

    1. STOP WORKFLOW IMMEDIATELY
    2. Document the specific ambiguities found
    3. Output: "WORKFLOW STOPPED: [Explanation]. Recommend dispatching new agent with clarified [specific items]"
    4. Remember: Building 2,300 lines for a 10-line config is worse than asking for clarity.
    Enhanced Thinking
    Tools:SequentialThinking*
    Effort:high
    Guardrails
    • gate_criteria: Must pass all validation checks before proceeding
    • prevent_complexity: Requirements must prevent unnecessary complexity
    • fail_fast: Stop immediately if requirements unclear
    • escape_trigger: Any ambiguity in requirements
    • fail_communication: Must document ambiguities and recommend re-dispatch with specific clarifications
    • lesson_learned: 2,300 lines for 10-line config = catastrophic failure. Always fail fast instead.
  5. 5.

    📝 Write Test Cases

    Create automated tests for each micro-task to ensure correctness.

    🧠 ENHANCED THINKING REQUIRED: Use the SequentialThinking tool and context7 to work through this systematically.

    Are all edge cases covered? Do tests validate both positive and negative scenarios?

    Enhanced Thinking
    Tools:SequentialThinking*
    Effort:high
    Guardrails
    • test_completeness: Must cover both positive and negative scenarios
    • edge_case_coverage: All edge cases must be tested
  6. 6.

    🔨 Implement Solution

    Execute micro-tasks exactly as specified. No additions beyond requirements.

    Git tracking: Commit after each micro-task completion with: git add -A && git commit -m 'feat: [specific change description]'

    🧠 ENHANCED THINKING REQUIRED: Use the SequentialThinking tool and context7 to work through this systematically.

    Does this implementation match specifications exactly? Am I adding complexity beyond what's specified?

    Enhanced Thinking
    Tools:SequentialThinking*
    Effort:high
    Guardrails
    • no_additions: No features beyond requirements
    • ma_protocol: Must follow Ma Protocol principles
    • test_alignment: Implementation must pass all tests
    • git_tracking: Commit after each micro-task
  7. 7.

    🗑️ Remove Deprecated Code

    Delete old implementations that have been replaced by new functionality.

    🧠 ENHANCED THINKING REQUIRED: Use the SequentialThinking tool and context7 to work through this systematically.

    What old code conflicts with new implementation? Are there backwards compatibility shims that should be removed? No deprecated features or backward compatibility shims are allowed.

    Enhanced Thinking
    Tools:SequentialThinking*Context7
    Effort:high
    Guardrails
    • complete_removal: Must remove ALL deprecated code, not partial cleanup
    • no_compatibility_shims: No backward compatibility allowed
    • evidence_based: Must provide evidence of complete removal
  8. 8.

    ✅ Validate Implementation

    Run all tests and validate against acceptance criteria.

    🧠 ENHANCED THINKING REQUIRED: Use the SequentialThinking tool and context7 to work through this systematically.

    1. Run all automated tests - must pass
    2. Validate against acceptance criteria - must meet all
    3. Document validation results before proceeding
    4. Verify git history: git log --oneline - all changes must be tracked

    NEVER claim completion without passing tests and meeting criteria.

    Enhanced Thinking
    Tools:SequentialThinking*Bash*
    Effort:high
    Guardrails
    • mandatory_evidence: Must provide concrete evidence of validation, not self-reports
    • complete_validation: All acceptance criteria must be verified
    • no_false_completion: Never claim completion without passing tests
  9. 9.

    🚪 Quality Gate: Build & Test Validation

    MANDATORY: Code must build successfully and all tests must pass.

    🧠 ENHANCED THINKING REQUIRED: Use the SequentialThinking tool and context7 to work through this systematically.

    1. Run dotnet build or npm run build - must return exit code 0
    2. For quality campaigns: Run specific validation commands
      • dotnet build 2>&1 | grep -E 'warning CA|error' | wc -l must equal 0
    3. Run dotnet test or npm test - all tests must pass
    4. Document validation evidence before claiming completion
    5. Verify git history is clean: git status - no uncommitted changes

    CRITICAL: Self-reported completion without validation evidence is FORBIDDEN.

    Enhanced Thinking
    Tools:SequentialThinking*Bash*
    Effort:high
    Guardrails
    • mandatory_validation: Must provide evidence, not self-reported completion
    • zero_tolerance: Build must succeed with exit code 0
    • test_requirement: All tests must pass
  10. 10.

    🔍 Anti-Slop Retrospective

    Analyze for AI-generated technical debt and process improvements.

    🧠 ENHANCED THINKING REQUIRED: Use the SequentialThinking tool and context7 to work through this systematically.

    What patterns indicate AI over-engineering? How can specifications be clearer? What process improvements prevent slop?

    Enhanced Thinking
    Tools:SequentialThinking*WriteMemory*Context7
    Effort:high
    Guardrails
    • pattern_extraction: Must identify specific actionable patterns, not generic observations
    • knowledge_preservation: All findings must be documented for future sprints
    • continuous_improvement: Focus on preventing future technical debt, not just identifying current issues
  11. 11.

    📝 Update TODO & CHANGELOG

    Update project tracking documents with completed work and validation evidence.

    TODO.md Updates:

    1. Mark completed tasks as done WITH VALIDATION EVIDENCE
    2. Include specific metrics (e.g., '16 violations → 0 violations')
    3. Add any new tasks discovered during validation
    4. Update priorities if needed
    5. Note any blockers or dependencies

    CHANGELOG.md Updates (if significant changes):

    1. Add entry under [Unreleased]
    2. Use appropriate section: Added/Changed/Fixed/Removed
    3. Write clear, user-focused descriptions
    4. Include validation metrics and evidence
    5. Reference issue numbers if applicable

    Only update CHANGELOG for significant changes, not minor refactoring.

    Effort:low
    Guardrails
    • evidence_required: Must include validation evidence, not just completion claims
    • appropriate_scope: Only update CHANGELOG for significant changes