.mdc file not really having any effects

Discussion
1

So, I have my .mdc file set to always attached, yet I’m not seeing it actually use what I put in there during daily workflow. For context, here’s the mdc file:
"When encountering an issue, the agent will execute the following structured process for issue resolution:

  1. Investigate the Issue:

  • Clearly define the issue encountered.

  • Gather relevant contextual information and identify key symptoms and behaviors.

  1. Generate 3 or More Possible Root Causes:

  • List a minimum of three distinct, plausible root causes.

  • Provide a concise explanation of each potential cause.

  1. Assess the Likelihood of Each Root Cause:

  • Evaluate each identified root cause based on available evidence.

  • Assign a likelihood rating (e.g., High, Medium, Low) to each root cause with brief reasoning for each assessment.

  1. Generate 3 or More Possible Solutions:

  • Propose at least three viable solutions addressing the identified root causes.

  • Clearly articulate the intended outcome of each solution.

  1. Assess Solutions Based on Defined Criteria:
Evaluate each solution according to criteria such as:
- Elegance (simplicity, minimalism, clarity)
- Architectural integrity (compatibility with existing architecture, maintainability)
- Efficiency (resource usage, speed, responsiveness)
- Feasibility (ease of implementation, practicality)
- Sustainability (long-term effectiveness, adaptability to future changes)
  1. Select the Optimal Solution:

  • Choose the solution best aligned with the above criteria.

  • Document reasoning for the final selection, clearly explaining why it was chosen over alternatives.

  1. Plan Implementation Steps:

  • Outline specific implementation steps required for the selected solution.

  • Identify necessary resources and potential obstacles.

  1. Develop and Execute Tests for the Solution:

  • Create specific tests to validate the effectiveness and reliability of the solution.

  • Conduct tests thoroughly and document results clearly.

  1. Implement and Monitor the Solution:

  • Execute the implementation plan methodically.

  • Monitor closely to ensure the solution effectively resolves the issue.

  1. Evaluate Outcomes and Document Results:

  • Assess the effectiveness of the implemented solution based on initial expectations and testing results.

  • Document the outcomes and insights gained for future reference and continuous improvement.
    "
    When I specifically ask it what to do when it finds an issue, it does tell me what it should, but I’m not seeing it actually do anything in the workflow that looks like what I just described it should do, is it an issue with how it’s worded?

2

I see a few issues:

  1. Activation Trigger: The workflow doesn’t clearly define “encountering an issue”—there’s no specific trigger that would prompt the agent to initiate this process automatically.
  2. Rule Application Context: The “alwaysApply: true” setting doesn’t guarantee the process runs automatically - it simply ensures the rule is loaded and available, but something must still trigger its execution.
  3. Lack of Explicit Instructions: While the file describes what the agent “will” do, it doesn’t contain explicit commands for the agent to recognize when to apply this process.

Try this:

---
description: "IssueResolutionFramework"
globs: 
alwaysApply: true
---
# Issue Resolution Framework 1.0

## 🔍 Activation Triggers
ISSUE_DETECTED = code_error ∨ test_failure ∨ runtime_error ∨ user_reports_issue
MANUAL_TRIGGER = user_command(/resolve, /fix, /debug)

## 📊 Process State
Π = [INACTIVE, INVESTIGATING, ANALYZING, SOLVING, IMPLEMENTING, EVALUATING]
current_state = Π[0]

## 📋 Resolution Steps
S = [investigate, identify_causes, assess_causes, propose_solutions, 
     evaluate_solutions, select_solution, plan_implementation, 
     develop_tests, implement, monitor, document]

## 🔄 Process Workflow

### Step 1: Investigation
S₁ = investigate(issue) ⟶ {
  define_issue(clear_description),
  gather_context(relevant_information),
  identify_symptoms(key_behaviors)
} ⟶ update(current_state = Π[1])

### Step 2: Root Cause Analysis
S₂ = identify_causes(issue) ⟶ {
  generate_causes(minimum=3),
  for each cause: {
    describe(cause),
    explain(mechanism)
  }
} ⟶ update(current_state = Π[2])

### Step 3: Likelihood Assessment
S₃ = assess_causes(causes[]) ⟶ {
  for each cause in causes: {
    evaluate_evidence(cause),
    assign_likelihood(HIGH|MEDIUM|LOW),
    provide_reasoning(assessment)
  }
} ⟶ update(current_state = Π[2])

### Step 4: Solution Generation
S₄ = propose_solutions(causes[]) ⟶ {
  generate_solutions(minimum=3),
  for each solution: {
    describe(solution),
    state_intended_outcome(solution)
  }
} ⟶ update(current_state = Π[3])

### Step 5: Solution Assessment
S₅ = evaluate_solutions(solutions[]) ⟶ {
  criteria = [elegance, architectural_integrity, efficiency, feasibility, sustainability],
  for each solution in solutions: {
    for each criterion in criteria: {
      assess(solution, criterion),
      rate(HIGH|MEDIUM|LOW),
      explain_rating(solution, criterion)
    }
  }
} ⟶ update(current_state = Π[3])

### Step 6: Solution Selection
S₆ = select_solution(solutions[]) ⟶ {
  select_optimal(solutions),
  explain_selection(reasoning),
  contrast_with_alternatives(why_better)
} ⟶ update(current_state = Π[3])

### Step 7: Implementation Planning
S₇ = plan_implementation(solution) ⟶ {
  outline_steps(specific_actions),
  identify_resources(needed_resources),
  anticipate_obstacles(potential_problems)
} ⟶ update(current_state = Π[4])

### Step 8: Testing Development
S₈ = develop_tests(solution) ⟶ {
  create_test_cases(validate_effectiveness),
  define_success_criteria(measurable_outcomes)
} ⟶ update(current_state = Π[4])

### Step 9: Implementation & Monitoring
S₉ = implement(solution, plan, tests) ⟶ {
  execute_plan(methodically),
  monitor_results(continuously),
  verify_resolution(issue_fixed)
} ⟶ update(current_state = Π[4])

### Step 10: Evaluation & Documentation
S₁₀ = evaluate_and_document(solution, results) ⟶ {
  assess_effectiveness(against_expectations),
  document_process(steps_taken),
  record_insights(lessons_learned)
} ⟶ update(current_state = Π[5]) ⟶ reset(current_state = Π[0])

## 🔄 Workflow Execution
execute_resolution = ISSUE_DETECTED ∨ MANUAL_TRIGGER ⟶ {
  update(current_state = Π[1]),
  for each step in S[0:10]: {
    execute(step),
    if step_complete: continue,
    else: request_more_information()
  }
}

## 📝 Output Format
resolution_report = """
# Issue Resolution Report

## 🔍 Issue Definition
[Clear definition of the issue encountered]

## 🧠 Root Cause Analysis
[List of at least 3 potential causes with likelihood assessments]

## 💡 Solution Evaluation
[At least 3 potential solutions with criteria-based evaluation]

## ✅ Selected Solution
[Details of chosen solution with implementation plan]

## 🧪 Testing & Validation
[Testing approach and results]

## 📊 Outcome
[Final results and effectiveness assessment]
"""
1 Like
3

Thanks! I also noticed that gemini 2.5 seems to follow the instructions better which I guess alignes with everyone saying claude is more a powerhouse and doesn’t follow instructions well.

1 Like