# Project Workflow Analysis Blueprint Generator

> End-to-end workflow docs — CI/CD, service boundaries, data flow, auto-detect project type

- Skill: `mouadja02/project-workflow-analysis-blueprint-generator` (Agent Skill)
- Install (CLI): `npx skillmds@latest add mouadja02/project-workflow-analysis-blueprint-generator`
- Raw SKILL.md: https://api.skillmd.com/api/skills/mouadja02/project-workflow-analysis-blueprint-generator/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: DevOps & Infra
- Author: mouadja02 (https://skillmd.com/u/mouadja02)
- Updated: 2026-09-17
- Page: https://skillmd.com/skills/mouadja02/project-workflow-analysis-blueprint-generator

---


# Project Workflow Documentation Generator

## Configuration Variables

```
${PROJECT_TYPE="Auto-detect|.NET|Java|Spring|Node.js|Python|React|Angular|Microservices|Other"}
<!-- Primary technology stack -->

${ENTRY_POINT="API|GraphQL|Frontend|CLI|Message Consumer|Scheduled Job|Custom"}
<!-- Starting point for the flow -->

${PERSISTENCE_TYPE="Auto-detect|SQL Database|NoSQL Database|File System|External API|Message Queue|Cache|None"}
<!-- Data storage type -->

${ARCHITECTURE_PATTERN="Auto-detect|Layered|Clean|CQRS|Microservices|MVC|MVVM|Serverless|Event-Driven|Other"}
<!-- Primary architecture pattern -->

${WORKFLOW_COUNT=1-5}
<!-- Number of workflows to document -->

${DETAIL_LEVEL="Standard|Implementation-Ready"}
<!-- Level of implementation detail to include -->

${INCLUDE_SEQUENCE_DIAGRAM=true|false}
<!-- Generate sequence diagram -->

${INCLUDE_TEST_PATTERNS=true|false}
<!-- Include testing approach -->
```

## Generated Prompt

```
"Analyze the codebase and document ${WORKFLOW_COUNT} representative end-to-end workflows 
that can serve as implementation templates for similar features. Use the following approach:
```

### Initial Detection Phase

```
${PROJECT_TYPE == "Auto-detect" ? 
  "Begin by examining the codebase structure to identify technologies:
   - Check for .NET solutions/projects, Spring configurations, Node.js/Express files, etc.
   - Identify the primary programming language(s) and frameworks in use
   - Determine the architectural patterns based on folder structure and key components" 
  : "Focus on ${PROJECT_TYPE} patterns and conventions"}
```

```
${ENTRY_POINT == "Auto-detect" ? 
  "Identify typical entry points by looking for:
   - API controllers or route definitions
   - GraphQL resolvers
   - UI components that initiate network requests
   - Message handlers or event subscribers
   - Scheduled job definitions" 
  : "Focus on ${ENTRY_POINT} entry points"}
```

```
${PERSISTENCE_TYPE == "Auto-detect" ? 
  "Determine persistence mechanisms by examining:
   - Database context/connection configurations
   - Repository implementations
   - ORM mappings
   - External API clients
   - File system interactions" 
  : "Focus on ${PERSISTENCE_TYPE} interactions"}
```

### Workflow Documentation Instructions

For each of the `${WORKFLOW_COUNT}` most representative workflow(s) in the system:

#### 1. Workflow Overview
   - Provide a name and brief description of the workflow
   - Explain the business purpose it serves
   - Identify the triggering action or event
   - List all files/classes involved in the complete workflow

#### 2. Entry Point Implementation

**API Entry Points:**
```
${ENTRY_POINT == "API" || ENTRY_POINT == "Auto-detect" ? 
  "- Document the API controller class and method that receives the request
   - Show the complete method signature including attributes/annotations
   - Include the full request DTO/model class definition
   - Document validation attributes and custom validators
   - Show authentication/authorization attributes and checks" : ""}
```

**GraphQL Entry Points:**
```
${ENTRY_POINT == "GraphQL" || ENTRY_POINT == "Auto-detect" ? 
  "- Document the GraphQL resolver class and method
   - Show the complete schema definition for the query/mutation
   - Include input type definitions
   - Show resolver method implementation with parameter handling" : ""}
```

**Frontend Entry Points:**
```
${ENTRY_POINT == "Frontend" || ENTRY_POINT == "Auto-detect" ? 
  "- Document the component that initiates the API call
   - Show the event handler that triggers the request
   - Include the API client service method
   - Show state management code related to the request" : ""}
```

**Message Consumer Entry Points:**
```
${ENTRY_POINT == "Message Consumer" || ENTRY_POINT == "Auto-detect" ? 
  "- Document the message handler class and method
   - Show message subscription configuration
   - Include the complete message model definition
   - Show deserialization and validation logic" : ""}
```

#### 3. Service Layer Implementation
   - Document each service class involved with their dependencies
   - Show the complete method signatures with parameters and return types
   - Include actual method implementations with key business logic
   - Document interface definitions where applicable
   - Show dependency injection registration patterns

**CQRS Patterns:**
```
${ARCHITECTURE_PATTERN == "CQRS" || ARCHITECTURE_PATTERN == "Auto-detect" ? 
  "- Include complete command/query handler implementations" : ""}
```

**Clean Architecture Patterns:**
```
${ARCHITECTURE_PATTERN == "Clean" || ARCHITECTURE_PATTERN == "Auto-detect" ? 
  "- Show use case/interactor implementations" : ""}
```

#### 4. Data Mapping Patterns
   - Document DTO to domain model mapping code
   - Show object mapper configurations or manual mapping methods
   - Include validation logic during mapping
   - Document any domain events created during mapping

#### 5. Data Access Implementation
   - Document repository interfaces and their implementations
   - Show complete method signatures with parameters and return types
   - Include actual query implementations
   - Document entity/model class definitions with all properties
   - Show transaction handling patterns

**SQL Database Patterns:**
```
${PERSISTENCE_TYPE == "SQL Database" || PERSISTENCE_TYPE == "Auto-detect" ? 
  "- Include ORM configurations, annotations, or Fluent API usage
   - Show actual SQL queries or ORM statements" : ""}
```

**NoSQL Database Patterns:**
```
${PERSISTENCE_TYPE == "NoSQL Database" || PERSISTENCE_TYPE == "Auto-detect" ? 
  "- Show document structure definitions
   - Include document query/update operations" : ""}
```

#### 6. Response Construction
   - Document response DTO/model class definitions
   - Show mapping from domain/entity models to response models
   - Include status code selection logic
   - Document error response structure and generation

#### 7. Error Handling Patterns
   - Document exception types used in the workflow
   - Show try/catch patterns at each layer
   - Include global exception handler configurations
   - Document error logging implementations
   - Show retry policies or circuit breaker patterns
   - Include compensating actions for failure scenarios

#### 8. Asynchronous Processing Patterns
   - Document background job scheduling code
   - Show event publication implementations
   - Include message queue sending patterns
   - Document callback or webhook implementations
   - Show how async operations are tracked and monitored

**Testing Approach (Optional):**
```
${INCLUDE_TEST_PATTERNS ? 
  "9. **Testing Approach**
     - Document unit test implementations for each layer
     - Show mocking patterns and test fixture setup
     - Include integration test implementations
     - Document test data generation approaches
     - Show API/controller test implementations" : ""}
```

**Sequence Diagram (Optional):**
```
${INCLUDE_SEQUENCE_DIAGRAM ? 
  "10. **Sequence Diagram**
      - Generate a detailed sequence diagram showing all components
      - Include method calls with parameter types
      - Show return values between components
      - Document conditional flows and error paths" : ""}
```

#### 11. Naming Conventions
Document consistent patterns for:
- Controller naming (e.g., `EntityNameController`)
- Service naming (e.g., `EntityNameService`)
- Repository naming (e.g., `IEntityNameRepository`)
- DTO naming (e.g., `EntityNameRequest`, `EntityNameResponse`)
- Method naming patterns for CRUD operations
- Variable naming conventions
- File organization patterns

#### 12. Implementation Templates
Provide reusable code templates for:
- Creating a new API endpoint following the pattern
- Implementing a new service method
- Adding a new repository method
- Creating new domain model classes
- Implementing proper error handling

### Technology-Specific Implementation Patterns

**.NET Implementation Patterns (if detected):**
```
${PROJECT_TYPE == ".NET" || PROJECT_TYPE == "Auto-detect" ? 
  "- Complete controller class with attributes, filters, and dependency injection
   - Service registration in Startup.cs or Program.cs
   - Entity Framework DbContext configuration
   - Repository implementation with EF Core or Dapper
   - AutoMapper profile configurations
   - Middleware implementations for cross-cutting concerns
   - Extension method patterns
   - Options pattern implementation for configuration
   - Logging implementation with ILogger
   - Authentication/authorization filter or policy implementations" : ""}
```

**Spring Implementation Patterns (if detected):**
```
${PROJECT_TYPE == "Java" || PROJECT_TYPE == "Spring" || PROJECT_TYPE == "Auto-detect" ? 
  "- Complete controller class with annotations and dependency injection
   - Service implementation with transaction boundaries
   - Repository interface and implementation
   - JPA entity definitions with relationships
   - DTO class implementations
   - Bean configuration and component scanning
   - Exception handler implementations
   - Custom validator implementations" : ""}
```

**React Implementation Patterns (if detected):**
```
${PROJECT_TYPE == "React" || PROJECT_TYPE == "Auto-detect" ? 
  "- Component structure with props and state
   - Hook implementation patterns (useState, useEffect, custom hooks)
   - API service implementation
   - State management patterns (Context, Redux)
   - Form handling implementations
   - Route configuration" : ""}
```

### Implementation Guidelines

Based on the documented workflows, provide specific guidance for implementing new features:

#### 1. Step-by-Step Implementation Process
- Where to start when adding a similar feature
- Order of implementation (e.g., model → repository → service → controller)
- How to integrate with existing cross-cutting concerns

#### 2. Common Pitfalls to Avoid
- Identify error-prone areas in the current implementation
- Note performance considerations
- List common bugs or issues encountered

#### 3. Extension Mechanisms
- Document how to plug into existing extension points
- Show how to add new behavior without modifying existing code
- Explain configuration-driven feature patterns

**Conclusion:**
Conclude with a summary of the most important patterns that should be followed when 
implementing new features to maintain consistency with the codebase."