CycleTime Scope Limitations and Boundaries

October 22, 2025 · View on GitHub

Purpose

This document establishes clear boundaries for CycleTime's scope to prevent over-engineering and maintain focus on the core value proposition. CycleTime is a data and context provider for Claude Code, not a comprehensive project management platform.

Core Principle

CycleTime enhances Claude Code's existing capabilities rather than replacing them.

What CycleTime Does

✅ Core Functionality (In Scope)

Data Storage and Persistence

  • H2 embedded database for project data
  • Epic → Story → Subtask hierarchy storage
  • Basic dependency tracking (blocks/blocked relationships)
  • Cross-session project state persistence

Context Provision

  • MCP Resources exposing project data to Claude Code
  • Simple dependency graph traversal
  • Unblocked task identification through basic queries
  • Structured project context for Claude Code analysis

Basic Project Operations

  • CRUD operations for issues, projects, and dependencies
  • Manual status updates with basic validation
  • Simple data export/import for provider switching
  • Template-based project bootstrap

Claude Code Integration

  • MCP server implementation with Resources and Tools
  • Project context exposure for agent enhancement
  • Cross-session continuity through data persistence

✅ Acceptable Enhancements (Future Scope)

Provider Expansion

  • Additional storage providers (Linear, GitHub Issues) with proven need
  • Simple data migration between providers
  • Provider-specific feature adaptation (not abstraction)

Basic Automation

  • Simple dependency checking and unblocking
  • Basic validation of issue hierarchy constraints
  • Template expansion for common project types

What CycleTime Does NOT Do

❌ Complex Analysis and Intelligence (Out of Scope)

LLM-Powered Analysis

  • No complex task prioritization algorithms
  • No LLM-powered dependency analysis
  • No predictive project analytics
  • No automated requirement inference
  • No intelligent task estimation or recommendation engines

Advanced Project Management

  • No resource allocation optimization
  • No timeline prediction and management
  • No risk analysis and mitigation
  • No performance metrics and reporting
  • No team coordination and communication tools

❌ Agent Coordination and Management (Out of Scope)

Agent Framework Replacement

  • No custom agent implementations
  • No agent discovery and configuration management
  • No agent-to-agent communication protocols
  • No external agent coordination systems
  • No workflow orchestration between agents

Multi-Agent System Management

  • No parallel agent execution management
  • No agent state synchronization
  • No conflict resolution between agents
  • No agent performance monitoring
  • No agent delegation and routing systems

❌ Advanced Automation (Out of Scope)

Workflow Automation

  • No automatic issue progression based on complex criteria
  • No automated quality gate enforcement
  • No automatic documentation synchronization
  • No complex business rule execution
  • No automated project health monitoring

Integration Orchestration

  • No complex CI/CD pipeline management
  • No automatic deployment and release coordination
  • No external service integration management
  • No complex data synchronization across multiple systems

❌ Advanced User Interface (Out of Scope)

Graphical Interfaces

  • No web-based project dashboards
  • No rich graphical dependency visualization
  • No interactive project management UI
  • No real-time collaboration interfaces
  • No advanced reporting and analytics dashboards

Advanced Interaction Patterns

  • No complex wizard-based workflows
  • No advanced search and filtering capabilities
  • No customizable project views and layouts
  • No advanced notification and alerting systems

Decision Criteria

When evaluating new features or enhancements, use these criteria:

✅ Add the Feature If:

  1. Enhances Claude Code: Does this make Claude Code more effective at project work?
  2. Simple Data Operation: Is this fundamentally a CRUD operation or basic data query?
  3. Context Provision: Does this expose useful structured data to Claude Code?
  4. Solo Developer Focus: Does this specifically help solo developers manage project context?
  5. MCP Integration: Can this be implemented as MCP Resources or Tools?

❌ Reject the Feature If:

  1. Replaces Claude Code: Does this attempt to do what Claude Code already does well?
  2. Complex Analysis: Does this require LLM analysis or complex algorithms?
  3. Automation Override: Does this automate decisions that humans should make?
  4. Agent Coordination: Does this try to coordinate or manage Claude Code agents?
  5. Over-Engineering: Does this add complexity without clear solo developer benefit?

Complexity Warning Signs

Reject features that exhibit these warning signs:

Technical Complexity

  • Requires multiple LLM API calls
  • Needs complex state synchronization
  • Involves multi-step automated workflows
  • Requires advanced algorithms or ML models
  • Needs real-time data processing

Architectural Complexity

  • Requires new abstraction layers
  • Needs complex configuration management
  • Involves multi-service coordination
  • Requires advanced caching or optimization
  • Needs complex error handling and recovery

User Experience Complexity

  • Requires extensive user training or documentation
  • Needs complex setup or configuration
  • Involves multiple interaction modes
  • Requires advanced user interface elements
  • Needs complex workflow management

Scope Enforcement

Regular Reviews

  • Monthly architecture reviews against these limitations
  • Feature request evaluation using decision criteria
  • Periodic simplification audits to remove complexity creep

Documentation Updates

  • Update limitations when new scope boundaries are discovered
  • Document rejected features and rationale for future reference
  • Maintain examples of acceptable vs. rejected feature requests

Implementation Guards

  • Code review checklist includes scope boundary verification
  • Automated tests for core functionality (no advanced features)
  • Performance benchmarks that enforce simplicity

Examples of Rejected Features

❌ Rejected: Advanced Task Prioritization Engine

Request: "Add AI-powered task prioritization that analyzes code complexity, developer skill level, and project deadlines to automatically rank tasks."

Rejection Reason:

  • Complex LLM analysis (violates simplicity principle)
  • Automated decision-making (replaces human judgment)
  • Over-engineering (Claude Code can analyze context we provide)

Alternative: Provide basic priority field and dependency data; let Claude Code analyze and recommend.

❌ Rejected: Automated Documentation Synchronization

Request: "Automatically update architecture docs when code changes, using AST analysis to detect architectural changes."

Rejection Reason:

  • Complex automation (beyond basic CRUD operations)
  • Advanced analysis (AST parsing and architectural inference)
  • Workflow automation (replaces manual human review)

Alternative: Provide documentation templates and basic project context; let Claude Code suggest updates.

❌ Rejected: Multi-Agent Workflow Orchestration

Request: "Coordinate multiple Claude Code agents working on different parts of the project, with automatic handoffs and conflict resolution."

Rejection Reason:

  • Agent coordination (violates Claude Code integration principle)
  • Complex orchestration (beyond context provision)
  • External management (replaces Claude Code's native capabilities)

Alternative: Provide project context through MCP Resources; let Claude Code handle agent delegation.

Examples of Acceptable Features

✅ Accepted: Basic Dependency Validation

Request: "Validate that subtasks can't be marked complete if their parent story is still in backlog."

Acceptance Reason:

  • Simple data validation (basic CRUD constraint)
  • Enhances data quality for Claude Code analysis
  • No complex automation or analysis required

✅ Accepted: Issue Template Expansion

Request: "Add project type detection and provide appropriate issue templates (web app vs. API vs. mobile app)."

Acceptance Reason:

  • Template-based project bootstrap (within scope)
  • Improves solo developer experience
  • Simple conditional logic, no complex analysis

✅ Accepted: Provider Data Export

Request: "Add ability to export project data for migration to Linear or other providers."

Acceptance Reason:

  • Basic data operation (export/import within scope)
  • Supports provider flexibility principle
  • Simple data transformation, no complex orchestration

Maintaining Focus

CycleTime's value comes from doing a few things extremely well rather than attempting to be a comprehensive solution:

  1. Structured Data Storage: Reliable, fast H2-based storage
  2. Context Provision: Rich, structured project context for Claude Code
  3. Cross-Session Continuity: Seamless project state recovery
  4. Simple Operations: Basic CRUD with validation and dependency tracking

By maintaining these boundaries, CycleTime remains a focused, reliable tool that enhances Claude Code's capabilities without competing with them or introducing unnecessary complexity.