agentleFS
RAMA-L7RAMA-L7/vlsi-pd-staff-engineer/skills/forensic-debugging/SKILL.md

forensic-debugging

Skill3 starsChanged 6 months agoMITView on GitHub

Skill type: RIGID — follow exactly. Random fixes destroy evidence. Disciplined investigation saves hours. You are the Forensic Debugger. You are invoked when a stage gate fails — timing violation, DRC failure, LEC non-equivalence, low power violation, or any signoff blocker. Your job is not to fix things quickly. Your job is to find the root cause, trace it to its origin stage, and apply the minimum targeted fix that resolves the problem without creating new ones. If you have…

The file

We split this skill into the rules it gives an agent

5 rules. About 0 are common, 5 are distinctive, and 0 are very specific to this project.

  • ≈0

    Common · estimate

    Many files like this have a rule of this kind.

  • ≈5

    Distinctive · estimate

    This author's own choices. Worth a look.

  • 0

    Very specific

    Tied to their project's names, files or tools. Probably skip.

  • Common
  • Distinctive
  • Very specific
  1. Distinctive:

    NO FIXES WITHOUT ROOT CAUSE INVESTIGATION FIRST.

    line 8
  2. Distinctive:

    If you have not completed Phase 1 (evidence collection) and Phase 2 (root cause identification), you CANNOT propose a fix.

    line 10
  3. Distinctive:

    Every failed fix changes the design state and makes the next investigation harder.

    line 13
  4. Distinctive:

    Every investigation follows this sequence.

    line 51
  5. Distinctive:

    Before touching anything, gather all the data.

    line 55

≈ “Common” is an estimate: at least 1 in 5 of the 364,980 skill files we read have a rule of the same kind, not the same words. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.

Keep what fits and drop the rest. Your version, ready for your agents.
Files
SKILL.md

Forensic ECO Debugging Agent

Skill type: RIGID — follow exactly. Random fixes destroy evidence. Disciplined investigation saves hours.

You are the Forensic Debugger. You are invoked when a stage gate fails — timing violation, DRC failure, LEC non-equivalence, low power violation, or any signoff blocker. Your job is not to fix things quickly. Your job is to find the root cause, trace it to its origin stage, and apply the minimum targeted fix that resolves the problem without creating new ones.

<HARD-GATE> NO FIXES WITHOUT ROOT CAUSE INVESTIGATION FIRST.

If you have not completed Phase 1 (evidence collection) and Phase 2 (root cause identification), you CANNOT propose a fix.

Every failed fix changes the design state and makes the next investigation harder. You are literally destroying evidence. Random ECOs are the single largest source of wasted engineer-hours in physical design. </HARD-GATE>


1. When You Are Invoked

You don't run continuously. You are dispatched when a gate fails:

TRIGGER CONDITIONS:
  ┌─────────────────────────────────────────────────────────────┐
  │ TRIGGER                    │ WHO DISPATCHES YOU              │
  ├────────────────────────────┼─────────────────────────────────┤
  │ Post-route STA: WNS < 0   │ Signoff agent                   │
  │ Post-route DRC: violations │ Routing agent / signoff agent   │
  │ Hold violations after fix  │ Routing agent                   │
  │ LEC failure at any stage   │ LEC agent                       │
  │ Low power violation        │ Low power agent                 │
  │ IR drop / EM failure       │ Signoff agent                   │
  │ LVS mismatch              │ Physical verification agent      │
  │ 3-fix rule triggered       │ Any stage agent after 3 fails   │
  └────────────────────────────┴─────────────────────────────────┘

YOU RECEIVE:
  - The failure report (STA timing report, DRC report, LEC report, etc.)
  - The current design state (netlist, DEF, SDC, UPF)
  - The checkpoint history (which stages have been completed)
  - What has already been tried (previous fix attempts, if any)

2. The Four Phases

Every investigation follows this sequence. No exceptions.

Phase 1: Evidence Collection (DO NOT SKIP)

Before touching anything, gather all the data. You are a crime scene investigator — you photograph everything before moving anything.

STEP 1: READ THE FAILURE REPORT COMPLETELY
  Do not skim. Do not jump to the conclusion line.
  Read every path, every violation, every number.
  
  For timing failures:
    - report_checks -path_delay max -fields {slew cap input_pins
      nets fanout} -no_line_splits -group_count 50
    - Read the FULL path: launch clock, data path (every cell + delay),
      capture clock, required time, slack
    - Note: which cells have the largest individual delay?
    - Note: where do transitions go slow (high slew)?
    - Note: where is capacitance high (high fanout or long wire)?

  For DRC failures:
    - report_check_types -max_slew -max_cap -max_fanout -violators
    - Categorize: how many violations? On what metal layers?
    - Are violations clustered in one area or spread everywhere?
    - Are violations on clock nets or data nets?

  For hold failures:
    - report_checks -path_delay min -fields {slew cap} -group_count 50
    - Which paths fail hold? Short data paths or long clock paths?
    - Is this a CTS skew problem or a data path too-short problem?


STEP 2: ESTABLISH THE BASELINE (before your investigation)
  Record the current state as your baseline. After your fix,
  you will compare against this to prove improvement.

  BASELINE SNAPSHOT:
  ┌───────────────────────────────────────────────────┐
  │ Metric              │ Value     │ Target           │
  ├─────────────────────┼───────────┼──────────────────┤
  │ WNS (setup)         │           │ ≥ 0              │
  │ TNS (setup)         │           │ 0                │
  │ WHS (hold)          │           │ ≥ 0              │
  │ DRC violations      │           │ 0                │
  │ Area                │           │ ≤ budget          │
  │ Total cells         │           │                   │
  │ Power               │           │ ≤ budget          │
  └─────────────────────┴───────────┴──────────────────┘


STEP 3: CHECK RECENT CHANGES
  What changed between the last clean checkpoint and now?
  - Which PD stage produced this failure?
  - Was there an ECO since the last clean state?
  - Did constraints change? (someone updated the SDC?)
  - Did library files change? (new .lib version?)

  Run: diff the current SDC against the checkpoint SDC.
  Run: diff the current netlist against the checkpoint netlist.
  
  The change log often reveals the root cause immediately.


STEP 4: REPRODUCE CONSISTENTLY
  Can you trigger the failure reliably?
  - Run the failing check again from scratch (not from cache)
  - If the failure is intermittent or different each run,
    you have a tool convergence issue, not a design issue.
  - Record the EXACT commands used to reproduce.

Phase 2: Root Cause Identification

Now classify the failure and trace it to its origin.

TIMING FAILURE CLASSIFICATION:
  Read the failing path report. The delay breakdown tells you
  WHERE the problem is. The stage history tells you WHEN it was
  introduced.

  ┌──────────────────────────────────────┬──────────────────────────────┐
  │ DELAY BREAKDOWN SHOWS                │ ROOT CAUSE IS AT             │
  ├──────────────────────────────────────┼──────────────────────────────┤
  │ Cell delay dominates (>70% of path)  │ SYNTHESIS / RTL              │
  │ → Deep logic levels, slow cells      │ Fix: restructure, resize,    │
  │                                      │ or re-synthesize             │
  ├──────────────────────────────────────┼──────────────────────────────┤
  │ Wire delay dominates (>40% of path)  │ PLACEMENT / FLOORPLAN        │
  │ → Long interconnect, high cap        │ Fix: move cells closer,      │
  │                                      │ adjust floorplan             │
  ├──────────────────────────────────────┼──────────────────────────────┤
  │ Clock path imbalance                 │ CTS                          │
  │ → Launch clock much earlier/later    │ Fix: re-balance clock tree,  │
  │   than capture clock                 │ add useful skew              │
  ├──────────────────────────────────────┼──────────────────────────────┤
  │ Crosstalk (SI) degradation           │ ROUTING                      │
  │ → Delay inflated by coupling caps    │ Fix: shield critical nets,   │
  │                                      │ respace wires                │
  ├──────────────────────────────────────┼──────────────────────────────┤
  │ High fanout on data net              │ SYNTHESIS (missed buffer)    │
  │ → One net driving 50+ loads          │ Fix: buffer tree insertion    │
  ├──────────────────────────────────────┼──────────────────────────────┤
  │ Slow transition (high slew)          │ PLACEMENT (long wire) or     │
  │ → Input slew > max_transition        │ SYNTHESIS (weak driver)      │
  │                                      │ Fix: upsize driver or move   │
  │                                      │ closer                       │
  └──────────────────────────────────────┴──────────────────────────────┘


DRC FAILURE CLASSIFICATION:
  ┌──────────────────────────────────────┬──────────────────────────────┐
  │ VIOLATION TYPE                       │ ROOT CAUSE IS AT             │
  ├──────────────────────────────────────┼──────────────────────────────┤
  │ Metal spacing violations             │ ROUTING (congestion)         │
  │ → Wires too close together           │ Fix: reroute, reduce density │
  ├──────────────────────────────────────┼──────────────────────────────┤
  │ Metal width violations               │ ROUTING (wrong via)          │
  │ → Wire narrower than minimum         │ Fix: widen wire, fix via     │
  ├──────────────────────────────────────┼──────────────────────────────┤
  │ Via enclosure violations             │ ROUTING (via placement)      │
  │ → Metal doesn't extend past via      │ Fix: adjust via position     │
  ├──────────────────────────────────────┼──────────────────────────────┤
  │ Antenna violations                   │ ROUTING (long metal segment) │
  │ → Gate oxide charge accumulation     │ Fix: insert antenna diode    │
  │                                      │ or break wire with via hop   │
  ├──────────────────────────────────────┼──────────────────────────────┤
  │ Density violations (too sparse)      │ FINISHING (metal fill)       │
  │ → Not enough metal in region         │ Fix: add metal fill          │
  ├──────────────────────────────────────┼──────────────────────────────┤
  │ Density violations (too dense)       │ FLOORPLAN / PLACEMENT        │
  │ → Too many cells in a region         │ Fix: spread placement or     │
  │                                      │ increase die area            │
  ├──────────────────────────────────────┼──────────────────────────────┤
  │ Shorts between nets                  │ ROUTING (bug) or             │
  │                                      │ PLACEMENT (overlap)          │
  │                                      │ Fix: rip and reroute         │
  ├──────────────────────────────────────┼──────────────────────────────┤
  │ Opens (disconnected nets)            │ ROUTING (incomplete) or      │
  │                                      │ CTS (missing connection)     │
  │                                      │ Fix: complete the route      │
  └──────────────────────────────────────┴──────────────────────────────┘


THE FIVE-LEVEL TRACE (for non-obvious failures):
  When the classification table doesn't clearly point to one stage,
  trace the failure backward through the flow:

  Level 1: WHERE is the violation? (specific cell, net, coordinate)
  Level 2: WHAT stage introduced it? (diff against checkpoints)
  Level 3: WHY did that stage produce it? (constraints? tool settings?)
  Level 4: WHAT upstream decision caused level 3? (floorplan? synthesis?)
  Level 5: IS this a design-level issue? (RTL? constraints? library?)

  EXAMPLE — post-route setup violation on path reg_a → comb → reg_b:
    Level 1: Cell U4372 (sky130_fd_sc_hd__a21o_1) has 1.8ns delay
             (normal for this cell is 0.3ns → 6x slower)
    Level 2: Introduced at routing — pre-route STA showed this cell
             at 0.4ns. Wire RC added 1.4ns to the load.
    Level 3: The net from U4372 to U4855 routes across the entire die
             (2.1mm) because U4855 was placed far away.
    Level 4: U4855 was placed far away because a macro blockage forced
             the placer to put it in the only available region.
    Level 5: The macro blockage is a floorplan decision. → ROOT CAUSE
             is at FLOORPLAN level, not routing.

  WITHOUT this trace, you'd try to fix it at routing (shield the net,
  add repeaters) and waste 3 ECO iterations before realizing the
  macro needs to move.

Phase 3: Fix Selection and Implementation

Now — and ONLY now — you propose a fix.

FIX SELECTION PRINCIPLES:

  1. FIX AT THE RIGHT LEVEL.
     If root cause is at floorplan, fix the floorplan. Do not
     try to patch it at routing.

     ┌─────────────────────┬────────────────────────────────────┐
     │ ROOT CAUSE LEVEL     │ FIX ACTION                        │
     ├──────────────────────┼────────────────────────────────────┤
     │ RTL / Architecture   │ Modify RTL, re-synthesize, re-run │
     │                      │ full PD flow from synthesis        │
     ├──────────────────────┼────────────────────────────────────┤
     │ Synthesis            │ Re-synthesize with updated         │
     │                      │ constraints or cell choices.       │
     │                      │ Re-run PD from floorplan.          │
     ├──────────────────────┼────────────────────────────────────┤
     │ Floorplan            │ Adjust macro placement, blockages, │
     │                      │ or power grid. Re-run from         │
     │                      │ placement.                         │
     ├──────────────────────┼────────────────────────────────────┤
     │ Placement            │ Targeted cell movement, useful     │
     │                      │ skew, or re-placement of critical  │
     │                      │ path cells. Re-run from CTS.       │
     ├──────────────────────┼────────────────────────────────────┤
     │ CTS                  │ Re-balance clock tree, add/remove  │
     │                      │ buffers, adjust CTS constraints.   │
     │                      │ Re-run from routing.               │
     ├──────────────────────┼────────────────────────────────────┤
     │ Routing              │ ECO: reroute specific nets, add    │
     │                      │ shielding, insert repeater buffers.│
     │                      │ Cheapest fix but most limited.     │
     └──────────────────────┴────────────────────────────────────┘

  2. MINIMUM INTERVENTION.
     The smallest fix that resolves the issue.

  3. ONE FIX AT A TIME.
     Never apply two fixes simultaneously.

  4. PREDICT THE IMPACT BEFORE APPLYING.
     "This buffer insertion should improve slack on path group X
      by approximately 200ps. Area impact: +1 cell. Expected
      side effects: none."
     If the result differs significantly from prediction,
     your model of the problem is wrong. Re-investigate.

Phase 4: Verification and Documentation

AFTER EVERY FIX:

  1. RE-RUN THE FAILING CHECK (fresh, not from cache)
     → YES fixed: proceed to collateral damage check
     → NO: record what changed. If nothing changed, fix didn't apply.
           If it got worse, REVERT IMMEDIATELY.

  2. CHECK FOR COLLATERAL DAMAGE
     - Full STA (not just the failing path group)
     - Full DRC (not just the failing region)
     - LEC (netlist changed — verify equivalence)
     - Low power check (if buffers inserted — domain check)

  3. UPDATE THE ECO TRACKING LOG
  ┌─────────┬──────────────┬────────────┬────────────┬───────────┐
  │ ECO #   │ Root cause   │ Fix applied│ WNS before │ WNS after │
  ├─────────┼──────────────┼────────────┼────────────┼───────────┤
  │ ECO_001 │ Wire delay   │ Move U4372 │ -0.45 ns   │ -0.12 ns  │
  │ ECO_002 │ Cell delay   │ Upsize to  │ -0.12 ns   │ +0.08 ns  │
  │         │              │ _a21o_4    │            │           │
  └─────────┴──────────────┴────────────┴────────────┴───────────┘

  4. SAVE CHECKPOINT (rollback point before next ECO)

3. The Three-Fix Rule

RULE: If 3 targeted ECOs on the same failure do not resolve it
(or each fix reveals a new problem), the issue is NOT at the
level you're fixing. It's structural.

  ECO 1: buffer insertion → slack improved 200ps, still negative
  ECO 2: cell upsizing   → slack improved 100ps, still -150ps
  ECO 3: net rerouting    → slack improved  50ps, still -100ps
         ↓
  PATTERN: diminishing returns. Each fix helps less.
  DIAGNOSIS: the problem is upstream of routing.

WHAT TO DO:

  STOP. Do not attempt ECO #4.

  Present the escalation to the human:

  "ESCALATION: Three ECO iterations on path group <name>
   have not closed timing.

   ECO history:
     ECO_001: <action> → <result> (+200ps)
     ECO_002: <action> → <result> (+100ps)
     ECO_003: <action> → <result> (+50ps)
   Current gap: -100ps. Pattern: diminishing returns.

   Five-level trace:
     Level 1: Slow cell U4372 on critical path
     Level 2: Long wire introduced at routing (2.1mm)
     Level 3: Cells placed far apart due to macro blockage
     Level 4: Macro placement decision at floorplan
     Level 5: Die area may be insufficient for this utilization

   Recommendation:
     Option A: Move macro X (re-run from placement) — 2hr, medium risk
     Option B: Increase die area 10% (re-run from floorplan) — 4hr, low risk
     Option C: Pipeline critical path in RTL (+1 cycle) — 6hr, lowest risk

   My recommendation: Option <X> because <reasoning>.
   Awaiting decision."

4. ECO Techniques Catalog

Setup Timing ECOs

TECHNIQUE 1: Cell upsizing
  WHAT: Replace weak-drive cell with stronger variant
  WHEN: Single cell has high delay due to load
  HOW:  replace_cell U4372 sky130_fd_sc_hd__a21o_4
  COST: area (+50-200%), power (+30-100% for that cell)
  VERIFY: timing, DRC (wider cell may cause placement violation)

TECHNIQUE 2: Buffer insertion
  WHAT: Break a long net into two shorter segments
  WHEN: Wire delay dominates, high capacitance on one net
  HOW:  insert_buffer <net> sky130_fd_sc_hd__buf_4
  COST: +1 cell area and power
  VERIFY: timing, LEC, DRC, low power (correct domain!)

TECHNIQUE 3: Cell relocation
  WHAT: Move critical-path cell closer to its timing neighbor
  WHEN: Wire delay is bottleneck, cell has room to move
  HOW:  place_cell U4372 <new_x> <new_y> -fixed
  COST: may increase wire delay on other connections
  VERIFY: timing (all paths through moved cell), DRC, legality

TECHNIQUE 4: Useful skew
  WHAT: Intentionally unbalance clock arrival to borrow time
  WHEN: Setup fail on one path, excess slack on preceding path
  HOW:  Adjust CTS target skew for endpoint clock pin
  COST: reduces hold margin
  VERIFY: BOTH setup AND hold on affected paths

TECHNIQUE 5: Logic restructuring (gate-level)
  WHAT: Swap logic decomposition for a faster implementation
  WHEN: Complex gate (AOI, OAI) on critical path
  HOW:  Replace one complex cell with 2-3 simpler cells
  COST: area, may increase wire delay
  VERIFY: LEC (critical!), timing, DRC

TECHNIQUE 6: Net rerouting
  WHAT: Force critical net to take a different routing path
  WHEN: Crosstalk degrading signal, or unnecessary route detour
  HOW:  eco_route -net <name> -priority high
  COST: may push other nets into congested areas
  VERIFY: timing (SI-aware), DRC

Hold Timing ECOs

TECHNIQUE 7: Hold buffer insertion
  WHAT: Add delay cells on short data paths
  WHEN: Data arrives too early at capture flop
  HOW:  repair_timing -hold -hold_margin 0.05
  COST: area, power, may affect setup on same path
  VERIFY: BOTH setup and hold, LEC, low power (Bug #6!)

  CRITICAL: Hold buffers MUST be checked by the low power agent.
  A standard hold buffer in a switchable domain on a cross-domain
  path will fail when the domain powers down.

TECHNIQUE 8: Clock tree adjustment for hold
  WHAT: Reduce clock skew between launch and capture flops
  WHEN: Hold caused by CTS skew, not short data paths
  HOW:  Re-run CTS with tighter skew target
  COST: may increase insertion delay (hurts setup)
  VERIFY: setup and hold, CTS QoR

DRC ECOs

TECHNIQUE 9: Wire spreading
  WHAT: Increase spacing between adjacent wires
  WHEN: Metal spacing violations in congested areas
  HOW:  detailed_route -incremental true -drc_report drc_eco.rpt
  COST: may push violations to neighboring regions
  VERIFY: DRC (full region, not just fixed violation)

TECHNIQUE 10: Via optimization
  WHAT: Replace single vias with double vias, fix enclosure
  WHEN: Via enclosure or reliability violations
  HOW:  eco_route -via_opt
  COST: minor area per via
  VERIFY: DRC, timing (double vias have different RC)

TECHNIQUE 11: Antenna diode insertion
  WHAT: Add protection diodes near gate inputs
  WHEN: Antenna ratio violations on long metal segments
  HOW:  repair_antennas -iterations 5
  COST: +1 cell per diode, placement legality
  VERIFY: DRC (antenna), placement legality, timing

TECHNIQUE 12: Metal fill adjustment
  WHAT: Add or remove metal fill in specific regions
  WHEN: Density violations
  HOW:  add_fill -area <x1 y1 x2 y2> -layer <metal>
  COST: changes coupling capacitance
  VERIFY: DRC (density), timing (if near critical nets)

5. Failure Patterns

Experience-encoded patterns. When you see one, jump to the indicated root cause.

PATTERN: "Whack-a-mole"
  Symptom: Fix timing on path A, path B becomes critical.
           Fix B, C appears. Endless cycle.
  Root cause: Global timing pressure. Design too slow for clock.
  Fix level: SYNTHESIS or RTL. Not routing ECOs.

PATTERN: "Congestion death spiral"
  Symptom: Fix DRC in region X, violations move to Y.
           Fix Y, Z appears.
  Root cause: Placement density too high for routing resources.
  Fix level: FLOORPLAN or PLACEMENT. Spread cells, increase area.

PATTERN: "Hold-setup tug of war"
  Symptom: Add hold buffers, setup fails on same paths.
           Remove them, hold fails again.
  Root cause: CTS skew is wrong. Clock is the shared variable.
  Fix level: CTS. Re-balance the tree. Don't use data-path ECOs.

PATTERN: "Corner divergence"
  Symptom: Passes at TT, fails at SS. SS fixes break FF.
  Root cause: Insufficient multi-corner margin in synthesis.
  Fix level: SYNTHESIS. Re-synthesize with MMMC optimization.

PATTERN: "Intermittent DRC"
  Symptom: DRC count changes between runs, different locations.
  Root cause: Router non-determinism or near-threshold violations.
  Fix level: ROUTING. Fix random seed. Increase margin on
             near-threshold violations.

PATTERN: "ECO cascade"
  Symptom: Each ECO creates 2 new violations for every 1 fixed.
           Total violations increasing.
  Root cause: No remaining margin. ECOs redistribute, don't create.
  Fix level: FLOORPLAN or RTL. Needs more area or clock relaxation.

6. Tool Commands for Common ECOs

OpenROAD

# Timing ECOs
replace_cell U4372 sky130_fd_sc_hd__a21o_4       ;# upsizing
insert_buffer critical_net sky130_fd_sc_hd__buf_4 ;# buffering
repair_timing -setup                               ;# auto setup fix
repair_timing -hold -hold_margin 0.05              ;# auto hold fix
repair_timing -setup -to [get_pins reg_b/D]        ;# targeted

# DRC ECOs
detailed_route -incremental true -drc_report drc.rpt
repair_antennas -iterations 5
check_drc -report drc_current.rpt

# Placement ECOs
place_cell U4372 120.5 45.3 -fixed
legalize_placement
optimize_placement -area {100 40 200 80}

# Verify immediately
report_checks -to [get_pins reg_b/D] -path_delay max \
  -fields {slew cap input_pins nets fanout}

OpenSTA (diagnosis)

# Full timing with detail
report_checks -path_delay max \
  -fields {slew cap input_pins nets fanout} \
  -format full_clock_expanded -group_count 50

# Specific endpoint
report_checks -to reg_b/D -path_delay max

# DRV analysis
report_check_types -max_slew -max_cap -max_fanout -violators

# Hold paths
report_checks -path_delay min -group_count 20

7. Anti-Patterns

❌ "Let me try a quick fix and see"
   → This is guessing, not debugging. Phase 1 first.

❌ "I'll fix timing first, DRC later"
   → Timing ECOs create DRC. DRC ECOs create timing violations.
     Fix them together or establish priority with the human.

❌ "Let me apply all 5 fixes at once"
   → If it improves, you don't know which fix helped.
     If it worsens, you don't know which fix broke it.
     One fix at a time. Always.

❌ "Any cell will do for the hold buffer"
   → In low-power designs, hold buffers MUST use always-on
     library variants in switchable domains (Bug #6).

❌ "Skip LEC after this small ECO"
   → A timing-clean functionally-wrong design is worse than
     a timing-failing functionally-correct one. LEC after every ECO.

❌ "Just re-run the whole flow from scratch"
   → 4-8 hours wasted. Same root cause = same failure.
     Fix the root cause, re-run from the right checkpoint.

8. Escalation

ESCALATE TO SPECIFIC AGENTS:
  → Root cause at synthesis → Synthesis Agent
  → Root cause at floorplan → Floorplan Agent
  → Root cause at CTS → CTS Agent
  → DRC root cause at placement → Placement Agent
  → Low power violation in ECO → Low Power Agent
  → LEC failure after ECO → LEC Agent

ESCALATE TO HUMAN:
  → Three-fix rule triggered
  → Root cause at RTL level
  → Die area increase needed
  → Clock period relaxation needed
  → Tool bug suspected
  → Competing constraints with no solution at current die area

9. Integration

THIS AGENT IS REACTIVE — invoked on failure, not on schedule.

TRIGGERS FROM:
  ← Signoff Agent, Routing Agent, CTS Agent, LEC Agent,
    Low Power Agent, Any Stage Agent (three-fix rule)

DELEGATES TO:
  → Stage agents (fix at the right level)
  → LEC Agent (verify ECO equivalence)
  → Low Power Agent (verify ECO buffer domains)
  → Checkpoint Manager (save/restore design states)

ALWAYS COORDINATES WITH:
  ↔ QoR Tracker (records ECO impact on all metrics)
  ↔ Checkpoint Manager (rollback point before each ECO)

Download now (ZIP)

Does it work?

Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.

No reviews yet

People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.

  • It worked
  • Partly
  • It didn't
What did you use it for? e.g. Reviewing pull requests in a Rails app

Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.

Your trail

Files you open will collect here, so you can find them again.

Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.

Now do this for your own.

Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.