Content
60%Weight 40%Scale 1-5Reviews the quality of instructions and guidance provided to agents. Good implementation is clear, handles edge cases, and produces reliable results.
The body is well-structured for progressive disclosure — every reference file exists, is one level deep, and carries explicit load conditions — and the guidance is largely executable with useful verification patterns. Its main liability is token efficiency: roughly 250 of its 505 lines restate content already shown earlier in the file or already known to Claude.
Suggestions
Remove the self-duplicating sections: 'Getting Started Examples' repeats the solve/derivative/integral/eigenvalue/lambdify examples already shown under Core Capabilities and Patterns, and the 'Quick Reference: Most Common Functions' import block restates standard usage — cutting these would roughly halve the file without losing information.
Fix the non-executable snippets: import `Operator` in the quantum example (and define or remove `B`), give Patterns 2-3 self-contained imports and defined inputs (`x_data`), and replace the invalid `from sympy import evalf` with `expr.evalf()` / `from sympy import nsimplify, N`.
Add brief verification checkpoints to the flows that lack them, mirroring the existing solve-and-verify pattern — e.g. numerically spot-check a lambdified function against `evalf()` results, or confirm generated C code compiles.
| Dimension | Reasoning | Score |
|---|---|---|
Conciseness | The 505-line body duplicates itself across sections: `solve(x**2 - 5*x + 6)` appears in both 'Pattern 1' and 'Example 1', derivative demos repeat between 'Calculus' and 'Example 2', `lambdify` is demonstrated three times, and the assumptions snippet appears twice, plus a 30-line import 'Quick Reference' that restates standard usage Claude already knows. This matches anchor 2 ('noticeably verbose; several unnecessary or padded sections') rather than 3, where padding would be incidental rather than whole duplicated sections. | 2 / 5 |
Actionability | Nearly all guidance is concrete, executable code with expected outputs in comments (e.g. `integrate(exp(-x), (x, 0, oo)) # 1`). Minor gaps keep it below 5: the quantum snippet uses `Operator('A')` without importing `Operator` and references undefined `B`, Patterns 2-3 use undefined `x_data` and unimported names, and `from sympy import evalf` in the Quick Reference is not a valid top-level SymPy import. | 4 / 5 |
Workflow Clarity | Sequencing is clear ('Always Define Symbols First' -> assumptions -> exact arithmetic -> choose solver) and 'Pattern 1: Solve and Verify' includes an explicit validation loop (`assert result == 0`), while the symbolic-to-numeric pipeline is numbered step-by-step. It is not 5 because some flows (codegen, dsolve, lambdify output) lack verification checkpoints. No destructive or batch operations are involved, so the workflow-clarity cap does not apply. | 4 / 5 |
Progressive Disclosure | The five referenced files (core-capabilities.md, matrices-linear-algebra.md, physics-mechanics.md, advanced-topics.md, code-generation-printing.md) all exist, are clearly signaled per section ('For detailed X: See references/...'), are one level deep, and get explicit 'Load when:' conditions in the Reference Files Structure section. It falls short of anchor 5 because the main file inlines substantial detail (Quick Reference, Getting Started Examples, Integration sections) that a lean overview would push to references. | 4 / 5 |
Total | 14 / 20 Passed |