By Wednesday evening, November 26, I had identified eight exceptional files.
Gold standard coordinators. Gold standard workers. Gold standard standards.
Files that demonstrated best practices. Files that worked perfectly.
But they were specific to their workflows. How do I make those patterns reusable?
The Gold Standard Problem
Thursday morning, November 27, I looked at the exceptional coordinator file.
Perfect structure. Clear sections. Logical flow. Precise instructions. Clean delegation.
But it was specific to one workflow. Specific context. Specific workers. Specific logic.
If I built a new workflow, I couldn’t just copy this file. The specifics wouldn’t transfer. But the patterns should.
I needed to extract patterns from gold standards and codify them into templates.
What Makes a Template
Templates aren’t gold standard files with different names. Templates are patterns extracted from gold standards.
A gold standard file shows one perfect implementation. A template shows the pattern that implementation followed.
Example from gold standard coordinator:
Phase 1: Pre-flight
Step 1: Invoke setup worker
Step 2: Read structured results
Step 3: Check for issues
Phase 2: Auto-fix Loop
Step 4: If issues exist, invoke fixing workers
Step 5: Invoke verification worker
Step 6: Loop back to Step 4 if issues remain
The specific workers are gold standard specifics. But the pattern is reusable:
Phase 1: Pre-flight
Run any setup workers needed
Collect structured data
Assess initial state
Phase 2: Fix Loop
If problems exist, invoke fixing agents
Run verification
Loop until clean or max iterations
Same pattern. Generic description. Applicable to any workflow.
That’s what templates capture: the underlying pattern, not the specific implementation.
Extracting the Templates
Thursday morning through afternoon, I extracted patterns from each gold standard type.
Coordinator patterns: Clear phase structure. Consistent step format. Clean loop logic. Structured data handling.
Worker patterns: Single responsibility. Minimal context. Clear inputs and outputs. Structured output format. Success criteria defined.
Standards patterns: Complete context. Good examples. Clear organization. Explaining rationale, not just requirements.
By Thursday afternoon, I had three templates. Gold patterns for coordinators. Gold patterns for workers. Gold patterns for standards.
I created a common standards directory at the project root. Not workflow-specific. Just templates.
Templates Enable Consistency
The templates serve primarily as evaluation benchmarks. When reviewing files across workflows, I compare them against template patterns.
Does this coordinator follow the phase structure pattern? Does this worker maintain single responsibility? Does this standards file provide complete context?
Templates create consistency. When every coordinator follows the same basic structure, coordinators become predictable. When patterns are consistent, understanding new files is faster.
Without templates, each workflow file gets evaluated in isolation. With templates, files get evaluated against codified gold standards. Consistent patterns across all workflows.
Evaluation Against Templates
Thursday afternoon, I updated the evaluation commands to compare files against templates.
Before: “Is this file clear, concise, and precise?”
After: “Is this file clear, concise, and precise? Does it follow the patterns from the template for this file type?”
Files weren’t just evaluated in isolation. They were evaluated against codified gold standards.
What I Learned
Gold standards need to become templates for reusability. Exceptional files show one perfect implementation. Templates extract the underlying patterns.
Templates capture structure, not specifics. They enable consistency and reduce reinvention.
Templates Provide the Target
Thursday, November 27, around 5 PM, I committed the common standards templates.
Three template files. Coordinator patterns. Worker patterns. Standards patterns.
Existing workflows could now be evaluated against them. Every file compared to template patterns. Systematic evaluation for consistency.
But having templates didn’t automatically make all existing files exceptional. Eight files were gold standard. Most files were excellent. Some were just good.
Templates provided the benchmark. Now I needed to systematically evaluate every file against that benchmark and bring them all to exceptional quality. Dozens of files. Methodical work. One evaluation at a time.