Profile Creator

What this skill does

Transforms messy human intent and repository analysis into living operational domain profiles through collaborative knowledge engineering.

## Core Purpose

Bridge the semantic gap between non-technical user vision and AI-specific behavioral constraints by operationalizing collaboration:

**Humans contribute:** Vision, domain intuition, user stories, conceptual relationships (the "why" and "what")
**AI contributes:** Ontological validation, role taxonomy mapping, framework alignment, behavioral observation structuring (the "how" and "structure")

**Neither can do this well alone.** Profile Creator enables the synergy.

## The 6-Phase Pipeline

```
Phase 1: Intent Structuring (conversational)
    ↓ [User validates structured intent]

Phase 2: Repository Analysis (automated)
    ↓

Phase 3: Ontology Mapping (domain knowledge graphs)
    ↓ [User validates framework mappings]

Phase 4: Behavioral Synthesis (50+ observations)
    ↓

Phase 5: Profile Validation (AUTOMATED QUALITY GATE)
    ├─ Checklist: 8+ autonomy, inheritance, methodology depth
    ├─ IF FAIL → Regenerate Phase 4 (max 3 attempts)
    └─ IF PASS → Continue

Phase 6: Profile Generation (CLAUDE.md / AGENTS.md)
    ↓ [User reviews operational profile]
```

## Phase 1: Intent Structuring

**Objective:** Transform messy human input into structured intent object through conversational discovery.

**Interaction Model:** Guided questions (ONE at a time) with educational context. Model this on effective brainstorming sessions: pleasant, comfortable, distilling, teaching. No questionnaires (produce garbage). No free-form (too costly in tokens).

**Conversational Flow:**

**Question 1:** "What's the primary role or archetype for this profile?"

*Educational context:* "This becomes the identity - examples: 'Researcher', 'System Architect', 'Domain Linguist', 'Security Analyst'. Think about the main function this profile will perform."

Wait for response.

**Question 2:** "What's the domain focus - the specific area this profile operates in?"

*Educational context:* "Examples: 'CrewAI codebase analysis', 'API documentation', 'Infrastructure orchestration', 'User authentication flows'. This sets the boundaries for where expertise applies."

Wait for response.

**Question 3:** "Single profile or multi-role structure?"

*Educational context:* "Single = one operational profile doing everything. Multi-role = System Owner orchestrating specialized backroom profiles. Multi-role enables expertise delegation (like Researcher + Domain Linguist + Codebase Analyst working together)."

Wait for response.

**Question 4:** "Any critical behavioral constraints - must-have behaviors?"

*Educational context:* "Examples: 'hallucination prevention', 'peer review required', 'security-first', 'systematic validation'. These become behavioral programming priorities that shape how the profile operates."

Wait for response.

**Question 5:** "Repository URL (if analyzing existing codebase)?"

*Context:* "GitHub/GitLab URL we'll analyze for technical patterns, frameworks, architecture. Leave empty if creating profile without repo analysis."

Wait for response.

**Question 6:** "Any additional study links?"

*Context:* "Framework documentation, domain resources, or specific files that provide context. Optional but helpful for accuracy."

Wait for response.

**Produce Structured Intent:**

```javascript
intent: {
  primary_role: "Researcher",           // From Q1
  domain_focus: "CrewAI codebase",      // From Q2
  team_structure: "multi-role",         // From Q3: "single" or "multi-role"
  key_constraints: ["hallucination prevention", "systematic methodology"] // From Q4
}

repository: "https://github.com/joaomdmoura/crewai" // From Q5 (optional)
study_links: ["..."] // From Q6 (optional)
```

**Validation Checkpoint:** Present structured intent to user:

"Here's the structured intent I've captured: [display intent object]. Does this capture your vision? [Confirm / Adjust]"

If Adjust → Iterate on specific fields. If Confirm → Proceed to Phase 2.

## Phase 2: Repository Analysis

**Objective:** Extract technical patterns, frameworks, architecture, tools from repository.

**Implementation:** Use direct file system tools (Glob/Read/Grep) - NO MCP to preserve session time.

**Analysis Steps:**

1. **Framework Detection:**
   - Glob for `package.json`, `requirements.txt`, `Cargo.toml`, `go.mod`
   - Read manifests → Identify frameworks (CrewAI, LangChain, Autogen, etc.)

2. **Architecture Patterns:**
   - Glob for directory structure (`src/`, `plugins/`, `skills/`, etc.)
   - Identify architectural patterns (plugin system, agent framework, etc.)

3. **Technical Patterns:**
   - Grep for key patterns: `Agent`, `Task`, `Crew`, API signatures
   - Extract methodology hints from code structure

4. **Documentation Analysis:**
   - Read `README.md`, `docs/` directory
   - Extract domain context and usage patterns

**Output:** `repository_analysis` object with frameworks, architecture, tools, patterns.

## Phase 3: Ontology Mapping

**Objective:** Map user intent and repository patterns to domain knowledge graphs.

**Domain Knowledge Sources:**
- Framework documentation (CrewAI, LangChain, Autogen, Semantic Kernel, LangGraph)
- Role taxonomies (Researcher, Architect, Engineer, etc.)
- Behavioral programming patterns (from Axivo collaboration platform)
- Study links provided by user

**Mapping Process:**

1. **Role Definition:** Map `primary_role` to known role patterns and methodologies
2. **Framework Mapping:** Match detected frameworks to their ontologies (Agent.goal(), Crew.kickoff(), etc.)
3. **Domain Validation:** Verify mappings against study_links to prevent hallucinations
4. **Constraint Translation:** Convert `key_constraints` to specific behavioral observations

**Validation Checkpoint:** "I'm mapping to these frameworks and patterns: [display mappings]. Does this match your understanding? Any additional resources I should reference?"

User can confirm, add study links, or correct mappings. Critical for preventing hallucinated framework features.

## Phase 4: Behavioral Synthesis

**Objective:** Generate 50+ behavioral observations with execution protocol, methodology, and inheritance.

**Synthesis Components:**

1. **Execution Protocol:**
   - **Autonomy:** 8+ observations for self-assertion (e.g., "Assert research expertise", "Challenge flawed assumptions")
   - **Monitoring:** Bias detection, drift monitoring (e.g., "Detect confirmation bias", "Verify source credibility")

2. **Methodology Techniques:**
   - 4+ per domain from framework patterns
   - Process steps, decision heuristics, validation approaches

3. **Inheritance:**
   - Inject COLLABORATION base behaviors
   - Add domain-specific inheritance chains

4. **Observations:**
   - 4-5 per methodology category
   - Behavioral constraints that guide formulation
   - Monitoring observations for problematic patterns

**Template-Based Enrichment:** Use universal templates + framework-specific patterns + user constraints to generate observations systematically.

**Output:** `behavioral_synthesis` object with observations, execution_protocol, methodology_techniques.

## Phase 5: Profile Validation (THE KILLER GATE)

**Objective:** Automated quality enforcement - catches 95% of issues before user sees them.

**Quality Checklist:**

```javascript
validation_checklist = {
  autonomy_observations: count >= 8,
  inheritance_relations: exists && includes("COLLABORATION"),
  methodology_techniques: count >= 4 per domain,
  hallucination_prevention: constraints.includes("hallucination prevention") || similar,
  reporting_hierarchy: if HMAS then complete else N/A,

  // Structural completeness
  has_identity: true,
  has_prime_directive: true,
  has_focus_areas: count >= 3 && count <= 5,
  has_domain_knowledge_graphs: sources.length >= 5,
  has_operational_methodology: process.length > 0
}
```

**Validation Logic:**

```javascript
if (all_checklist_passed) {
  proceed_to_phase_6();