Dark Factory: Autonomous Implementation Workflow

Purpose

This skill is a fully autonomous AI implementation factory. Given a Jira ticket ID (EPMCDME-XXXXX), it drives the complete cycle from requirements through to a merged MR — without asking for approvals at each step. It makes technical decisions, follows project patterns, self-reviews, validates in the browser, and creates the MR.

A Jira ticket is mandatory. Dark Factory does not accept free-form task descriptions as a starting point. If no ticket is provided, stop immediately and ask the user to provide one.

Core principle: Work autonomously. Resolve ambiguity through analysis, not questions. Only ask the user when requirements are genuinely unclear and cannot be inferred.

Autonomous Workflow

Phase 1 → Requirements & Jira Phase 2 → Complexity Assessment Phase 3 → Specification (Medium/Complex only) Phase 4 → Branch + Implementation Phase 5 → Code Review (auto-fix critical/major) Phase 6 → UI Validation (browser testing, no Jira publish) Phase 7 → Quality Gates + MR

Phase 1: Requirement Gathering

Step 1a: Gate — Jira Ticket Required

Check for a valid ticket ID (EPMCDME-XXXXX ) in the user's request.

✅ Ticket provided → continue to Step 1b

❌ No ticket provided → STOP. Respond with:

Dark Factory requires a Jira ticket to start. Please provide an EPMCDME-XXXXX ticket ID.

If you don't have a ticket yet, you can:

• Create one using the brianna skill: ask brianna to create a ticket for your task

• Create it directly in the CodeMie platform at the EPMCDME project board

Once you have a ticket, come back with the ID and I'll start implementation.

Do not proceed without a ticket. Do not accept a task description as a substitute.

Step 1b: Fetch Ticket Details

Fetch the ticket via brianna skill (NOT a sub-agent — call the skill directly):

Skill(skill="brianna", args="get ticket EPMCDME-XXXXX fields: description, summary")

• If the ticket doesn't exist: inform the user and stop

• If the ticket exists: continue

Step 1c: Check for Duplicates

Ask brianna to search for similar open tickets:

Skill(skill="brianna", args="search for tickets similar to [summary] in EPMCDME project, status: open")

• If duplicates found: note them and proceed (the provided ticket is the source of truth)

Step 1d: Clarifying Questions

Ask only if acceptance criteria are vague or ambiguous in a way that blocks implementation. Skip if requirements are clear.

Branch Naming

Always use the exact ticket ID as the branch name — no prefix, no suffix.

Format Example

EPMCDME-XXXXX

EPMCDME-10500

Phase 2: Complexity Assessment

Assess using the Complexity Assessment Guide.

Score each dimension (1=Simple, 2=Medium, 3=Complex):

• Component Scope (how many files/layers)

• Requirements Clarity

• Technical Risk

• File Change Estimate

• Dependencies

Total Score Complexity Path

5-7 Simple / Bug fix → Direct to Phase 4 (Implementation)

8-11 Medium → Phase 3 (Specification), then Phase 4

12-15 Complex → Phase 3 (Specification), then Phase 4

Special rule: Bug fixes and small isolated changes always go directly to Phase 4, regardless of score, unless they involve architectural risk.

Output a brief complexity summary before proceeding:

Complexity: [Simple | Medium | Complex] (Score: X/15)

• Scope: [summary]
• Risk: [summary]
• Files affected: [estimate] → Path: [Direct implementation | Specification first]

Phase 3: Specification (Medium and Complex Only)

Step 3a: Invoke Solution Architect

Delegate to the solution-architect sub-agent with full context:

Task(subagent_type="solution-architect", prompt=" Generate implementation plan for [ticket/task]. Requirements: [requirements text] Complexity: [Medium/Complex] Affected areas: [list from complexity assessment] Constraints: [any technical decisions already made] Coding standards: Follow CLAUDE.md and .codemie/guides/ ")

Step 3b: Review the Specification

Review the generated .md spec against the requirements:

Auto-proceed if:

• All acceptance criteria are covered

• The implementation path is clear

• No architectural ambiguity remains

Delegate back to architect if:

• A requirement is not addressed

• The approach contradicts project patterns

• A critical decision is left as TBD

Task(subagent_type="solution-architect", prompt=" Revise the spec. Issues found:

1. [Issue 1 - what's missing or wrong]
2. [Issue 2] The spec must address all acceptance criteria before implementation. ")

Repeat until the spec is implementation-ready.

Phase 4: Branch Creation and Implementation

Step 4a: Create Feature Branch

CRITICAL: Always create the branch before touching any code.

Ensure clean state on main

git checkout main git pull origin main

Create and push feature branch

git checkout -b EPMCDME-XXXXX # or feature/branch-name git push -u origin EPMCDME-XXXXX

If branch already exists locally: switch to it and pull latest (git checkout EPMCDME-XXXXX && git pull ).

Step 4b: Implement

Before coding, load the relevant guides from .codemie/guides/ (see CLAUDE.md Task Classifier).

Implementation order (respect layer dependencies):

• Types (src/types/ )

• Constants (src/constants/ )

• Store (src/store/ )

• Hooks (src/hooks/ )

• Components (src/components/ )

• Pages (src/pages/ )

• Router (src/router.tsx )

Coding standards (non-negotiable):

• Tailwind only — no custom CSS

• Use Popup, not Dialog

• API via custom fetch wrapper, parse with .json()

• Valtio stores for global state

• React Hook Form + Yup for forms

• cn() from @/utils/utils

• ?? not || for defaults

• Single quotes for strings

• Components under 300 lines

Commit incrementally with descriptive messages following conventional commits format:

<type>(<scope>): <imperative description>

Refs: EPMCDME-XXXXX

Where <type> is one of: feat , fix , docs , refactor , test , chore

And <scope> is one of: cli , agents , providers , assistants , config , proxy , workflows , analytics , utils , deps , tests , skills (omit if none applies)

Phase 5: Code Review

Invoke the code-reviewer sub-agent on all changed files:

Task(subagent_type="code-reviewer", prompt=" Review all changes made for [ticket/task] on branch [branch-name]. Focus on: correctness, React/TypeScript patterns, Valtio usage, Tailwind styling, accessibility, and security. Flag critical and major issues. ")

Auto-fix all critical and major issues found in the review output before continuing.

After fixing, re-run lint to confirm:

npm run lint:fix

Phase 6: UI Validation

Invoke the ui-tester sub-agent to verify the implemented functionality in the browser:

Task(subagent_type="ui-tester", prompt=" Verify the following functionality works correctly in the browser: [List of acceptance criteria / user flows] Base URL: http://localhost:5173 Do NOT post to Jira. Only verify and report pass/fail. ")

On failures: Fix the issue and re-run ui-tester until all scenarios pass.

Do NOT publish screenshots or test results to Jira automatically.

Phase 7: Quality Gates and MR

Step 7a: Run Quality Checks

Unit tests

npm test

Lint

npm run lint

Build check (optional for large changes)

npm run build

All checks must pass before creating the MR. Fix any failures.

Step 7b: Commit Final Changes

Stage and commit all remaining changes:

git add <specific files> git commit -m "$(cat <<'EOF' <type>(<scope>): final cleanup and fixes

Refs: EPMCDME-XXXXX EOF )" git push

Step 7c: Create Merge Request

Use the codemie-mr skill or create directly:

Skill(skill="codemie-mr", args="create MR for branch EPMCDME-XXXXX")

Or via gh CLI:

gh pr create --title "<type>(<scope>): [summary]" --body "$(cat <<'EOF'

Summary

• [Change 1]
• [Change 2]

Test Plan

• Unit tests pass
• Lint passes
• UI validation passed (ui-tester)

Related

• Jira: EPMCDME-XXXXX

🤖 Generated with Claude Code EOF )"

Error Handling

Ticket Not Found

Unable to fetch EPMCDME-XXXXX. Verify the ticket ID and Jira access. Stopping — cannot proceed without requirements.

Branch Already Exists

Automatically switch to it and continue:

git checkout EPMCDME-XXXXX git pull origin EPMCDME-XXXXX

Tests Failing

Do not create MR. Fix failing tests first, then re-run quality gates.

UI Validation Failures

Fix the reported issues and re-run ui-tester before proceeding to Step 7.

Key Principles

Do's

✅ Require a Jira ticket — block and redirect if none is provided ✅ Work autonomously — don't ask for approvals at each phase ✅ Fetch only required Jira fields (description, summary) ✅ Always check for duplicate/related tickets via brianna ✅ Create feature branch before any code changes ✅ Use complexity score to route: simple → direct, medium/complex → spec first ✅ Auto-fix critical and major code review issues ✅ Run UI validation before MR — fix failures before continuing ✅ Run tests and lint before MR

Don'ts

❌ Don't accept free-form task descriptions — always require EPMCDME-XXXXX first ❌ Don't ask "shall I proceed?" between phases — proceed autonomously ❌ Don't skip the Jira duplicate check ❌ Don't start coding before branch creation ❌ Don't publish UI test results to Jira automatically ❌ Don't create MR with failing tests or lint errors ❌ Don't use solution architect for simple/bug-fix tasks ❌ Don't guess at complexity — use the scoring matrix

Reference Files

• references/complexity-assessment-guide.md — Scoring criteria and examples

• references/branch-workflow.md — Git branching best practices

• examples/simple-feature-example.md — Full walkthrough: simple task

• examples/complex-feature-example.md — Full walkthrough: complex task

• examples/non-jira-task-example.md — Full walkthrough: no Jira ticket

Integration Points

Skill / Agent When How

brianna Phase 1 — ticket fetch + duplicate search Skill(skill="brianna", ...)

solution-architect Phase 3 — Medium/Complex spec Task(subagent_type="solution-architect", ...)

code-reviewer Phase 5 — code quality Task(subagent_type="code-reviewer", ...)

ui-tester Phase 6 — browser validation Task(subagent_type="ui-tester", ...)

codemie-mr Phase 7 — MR creation Skill(skill="codemie-mr", ...)