Dev Feedback Loop

Why this is mandatory:

• TodoWrite creates visible tracking of feedback-loop execution
• Prevents skill from being "forgotten" mid-execution
• Creates audit trail that feedback was collected
• Hook enforcer checks for this todo item

After completing all feedback-loop steps, mark as completed:

TodoWrite tool:
  todos:
    - id: "feedback-loop-execution"
      content: "Execute dev-feedback-loop: collect metrics, calculate scores, write report"
      status: "completed"
      priority: "high"

Anti-Rationalization:

You CANNOT proceed to Step 1 without executing TodoWrite above.

Pressure Resistance

See shared-patterns/shared-pressure-resistance.md for universal pressure scenarios.

Feedback-specific note: Feedback MUST be collected for every completed task, regardless of outcome or complexity. "Simple tasks" and "perfect scores" still need tracking.

Common Rationalizations - REJECTED

See shared-patterns/shared-anti-rationalization.md for universal anti-rationalizations.

Feedback-specific rationalizations:

Red Flags - STOP

See shared-patterns/shared-red-flags.md for universal red flags.

If you catch yourself thinking any of those patterns, STOP immediately. Collect metrics for every task.

Self-Preservation Bias Prevention

Agents must report accurately, even when scores are low:

Reporting protocol:

1. Calculate score using exact formula (no rounding)
2. Report score regardless of value
3. If score < 70, mandatory root cause analysis
4. Document honestly - "I made this mistake" not "mistake was made"
5. Patterns in low scores = improvement opportunities, not blame

Self-interest check: If you're tempted to adjust a score, ask: "Would I report this score if someone else achieved it?" If yes, report as-is.

Mandatory Feedback Collection

Non-negotiable: Feedback MUST be collected for every completed task, regardless of:

Consequence: Skipping feedback breaks continuous improvement loop and masks systemic issues.

Repeated Feedback Detection

When the same feedback appears multiple times:

Recurring feedback indicates systemic issue not being addressed.

Escalation format:

## RECURRING ISSUE - Escalation Required

**Issue:** [Description]
**Occurrences:** [Count] times across [N] tasks
**Pattern:** [What triggers this issue]
**Previous Responses:** [What was tried]

**Recommendation:** [Systemic fix needed]
**Awaiting:** User decision on root cause resolution

Threshold Alerts - MANDATORY RESPONSE

When thresholds are breached, response is REQUIRED:

You CANNOT proceed past threshold without documented response.

Blocker Criteria - STOP and Report

always pause and report blocker for:

Before skipping any feedback collection:

1. Check if task is complete (feedback required for all completed tasks)
2. Check threshold status (alerts are mandatory)
3. If in doubt → STOP and report blocker

You CANNOT skip feedback collection. Period.

Assertiveness Score Calculation

Base score of 100 points, with deductions for inefficiencies:

Penalty Matrix

Score Calculation Formula

score = 100 - min(30, extra_iterations*10) - review_fail*20 - needs_discussion*10 - min(40, unmet_criteria*10) | User rejected → score = 0

Score Interpretation

Step 1: Collect Cycle Metrics

MANDATORY: Execute this step for all tasks, regardless of:

• Score value (even 100%)
• User satisfaction (even immediate approval)
• Outcome quality (even perfect)

Anti-exemption check: If you're thinking "perfect outcome, skip metrics" → STOP. This is Red Flag at line 75 ("Perfect outcome, skip the metrics").

After task completion, gather from agent_outputs in state file:

Structured Data Fields (NEW)

The state file now contains structured error/issue data for direct analysis:

All gates have standards_compliance with:

• total_sections, compliant, not_applicable, non_compliant
• gaps[] - array of non-compliant sections with details

Reading Structured Data

# From state file, extract standards compliance from all gates:
all_standards_gaps = [
  ...agent_outputs.implementation.standards_compliance.gaps,
  ...agent_outputs.devops.standards_compliance.gaps,
  ...agent_outputs.sre.standards_compliance.gaps,
  ...agent_outputs.testing.standards_compliance.gaps,
  ...agent_outputs.review.code_reviewer.standards_compliance.gaps,
  ...agent_outputs.review.business_logic_reviewer.standards_compliance.gaps,
  ...agent_outputs.review.security_reviewer.standards_compliance.gaps
]

# Gate-specific errors/issues:
devops_errors = agent_outputs.devops.verification_errors
sre_errors = agent_outputs.sre.validation_errors
test_failures = agent_outputs.testing.failures
uncovered_acs = agent_outputs.testing.uncovered_criteria
review_issues = [
  ...agent_outputs.review.code_reviewer.issues,
  ...agent_outputs.review.business_logic_reviewer.issues,
  ...agent_outputs.review.security_reviewer.issues
]

# Aggregate standards compliance metrics:
total_standards_sections = sum(all_gates.standards_compliance.total_sections)
total_compliant = sum(all_gates.standards_compliance.compliant)
overall_compliance_rate = total_compliant / total_standards_sections * 100

Iteration Penalty Calculation

# Total extra iterations across all gates:
extra_iterations = (
  max(0, implementation.iterations - 1) +
  max(0, devops.iterations - 1) +
  max(0, sre.iterations - 1) +
  max(0, testing.iterations - 1) +
  max(0, review.iterations - 1)
)

Step 2: Calculate Assertiveness Score

Apply formula: Base 100 - deductions (extra iterations, review failures, unmet criteria) = Final Score / 100. Map to rating per interpretation table.

Step 3: Analyze Prompt Quality (Agents Only)

After calculating assertiveness, analyze prompt quality for all agents that executed in the task.

3.1 Load Agent Outputs

Read agent_outputs from state file (docs/dev-cycle/current-cycle.json or docs/dev-refactor/current-cycle.json):

Agents to analyze (if executed, not null):
  - implementation: backend-engineer-golang | backend-engineer-typescript
  - devops: devops-engineer
  - sre: sre
  - testing: qa-analyst
  - review: code-reviewer, business-logic-reviewer, security-reviewer

3.2 Dispatch Prompt Quality Reviewer

Task tool:
  subagent_type: "prompt-quality-reviewer"
  prompt: |
    Analyze prompt quality for agents in task [task_id].

    Agent outputs from state:
    [agent_outputs]

    For each agent:
    1. Load definition from dev-team/agents/ or default/agents/
    2. Extract rules: MUST, MUST not, ask_when, output_schema
    3. Compare output vs rules
    4. Calculate score
    5. Identify gaps with evidence
    6. Generate improvements

    Return structured analysis per agent.

3.3 Write Feedback Files

Directory: docs/feedbacks/cycle-YYYY-MM-DD/

One file per agent, accumulating all tasks that used that agent.

File: docs/feedbacks/cycle-YYYY-MM-DD/{agent-name}.md

# Prompt Feedback: {agent-name}

**Cycle:** YYYY-MM-DD
**Total Executions:** N
**Average Score:** XX%

---

## Task T-001 (Gate X)

**Score:** XX/100
**Rating:** {rating}

### Gaps Found

| Category | Rule | Evidence | Impact |
|----------|------|----------|--------|
| MUST | [rule text] | [quote from output] | -X |

### What Went Well

- [positive observation]

---

## Task T-002 (Gate X)

**Score:** XX/100
...

---

## Consolidated Improvements

### Priority 1: [Title]

**Occurrences:** X/Y tasks
**Impact:** +X points expected
**File:** dev-team/agents/{agent}.md

**Current text (line ~N):**

[existing prompt]

**Suggested addition:**
```markdown
[new prompt text]

Priority 2: [Title]

...

### 3.4 Append to Existing File

If file already exists (from previous task in same cycle), **append** the new task section before "## Consolidated Improvements" and update:
- Total Executions count
- Average Score
- Consolidated Improvements (re-analyze patterns)

## Step 3.5: Pattern Analysis from Structured Data (NEW)

**Analyze structured error/issue data to identify recurring patterns:**

### 3.5.1 Standards Compliance Patterns

```yaml
# Group gaps by section name
standards_gaps_by_section = group(all_implementation_gaps, by: "section")

# Identify recurring gaps (same section fails across tasks)
recurring_standards_gaps = filter(standards_gaps_by_section, count >= 2)

# Output pattern
For each recurring gap:
  - Section: [section name]
  - Occurrences: [N] tasks
  - Common reason: [most frequent reason]
  - Recommendation: [agent prompt improvement]

3.5.2 Review Issue Patterns

# Group review issues by category
issues_by_category = group(all_review_issues, by: "category")

# Group by severity for prioritization
issues_by_severity = group(all_review_issues, by: "severity")

# Identify top recurring categories
top_categories = sort(issues_by_category, by: count, descending).take(5)

# Output pattern
For each top category:
  - Category: [category name]
  - Occurrences: [N] issues across [M] tasks
  - Severity breakdown: [CRITICAL: X, HIGH: Y, MEDIUM: Z]
  - Most common: [most frequent description pattern]
  - Fix rate: [fixed_count / total_count]%

3.5.3 Test Failure Patterns

# Group failures by error_type
failures_by_type = group(all_test_failures, by: "error_type")

# Identify flaky tests (same test fails multiple times)
flaky_tests = filter(all_test_failures, count_by_test_name >= 2)

# Output pattern
For each error type:
  - Type: [assertion|panic|timeout|compilation]
  - Occurrences: [N] failures
  - Fix iterations: avg [X] iterations to fix

3.5.4 Cross-Gate Pattern Correlation

# Correlate: Do standards gaps predict review issues?
correlation_standards_review = correlate(
  implementation.standards_compliance.gaps[].section,
  review.*.issues[].category
)

# Output insight
If correlation > 0.5:
  "Standards gap in [section] correlates with review issues in [category]"
  → Recommendation: Strengthen agent prompt for [section]

Step 4: Threshold Alerts

Report formats: RCA = Score → Failure Events → 5 Whys → Root cause → Corrective action | Gate Blocked = History → Issue → BLOCKED UNTIL human decision | Deep Analysis = Distribution → Patterns → Improvement Plan

Step 5: Write Feedback Report

Location: .ring/dev-team/feedback/cycle-YYYY-MM-DD.md

Required sections:

Step 6: Generate Improvement Suggestions

Improvement types based on pattern analysis:

Step 7: Complete TodoWrite Tracking (MANDATORY FINAL ACTION)

⛔ HARD GATE: After all steps complete, you MUST mark feedback-loop todo as completed.

Execute this TodoWrite call to finalize:

TodoWrite tool:
  todos:
    - id: "feedback-loop-execution"
      content: "Execute dev-feedback-loop: collect metrics, calculate scores, write report"
      status: "completed"
      priority: "high"

Verification before marking complete:

• Step 1: Metrics collected from state file
• Step 2: Assertiveness score calculated
• Step 3: Prompt quality analyzed (if agents executed)
• Step 4: Threshold alerts checked
• Step 5: Feedback report written to .ring/dev-team/feedback/
• Step 6: Improvement suggestions generated

You CANNOT mark todo as completed until all steps above are done.

Execution Report

Base metrics per shared-patterns/output-execution-report.md.

Anti-Patterns

Never:

• Skip feedback collection for "simple" tasks
• Ignore threshold alerts
• Accept low scores without analysis
• Generate suggestions without data
• Blame individuals instead of process

Always:

• Track every gate transition
• Calculate score for every task
• Investigate scores < 70
• Document root causes
• Generate actionable improvements
• Review trends over time

Feedback Loop Integration