If your value ends at syntax, AI already replaced you.
The system prompt: coding_workflow_for_llms.json
Quick Start: Use the coding llm framework and wait for my first request: [copy&past the current coding_workflow_for_llms.json content here]
In the last post, we dropped a hard truth:
LLMs aren’t replacing developers — they’re exposing the ones who were already replaceable.
I argued that value no longer comes from typing code. It comes from thinking clearly, making deliberate decisions, and taking ownership over outcomes. AI doesn’t kill your job — but it does kill your shortcuts.
That post left one big question hanging:
So how do you build software in a world where AI can generate anything — but still understands nothing?
This post is a possible answer.
Meet SYNC — a rigorously structured, fact-enforced framework designed for developers who still give a damn.
SYNC doesn’t make AI smarter.
It provides a system prompt that makes your LLM coding process strong enough to survive dumb ideas, fast code, and thoughtless automation.
We’re going to break it down:
-
Phases
-
Agents
-
Tasks
So I’m currently trying to build an LLM coding framework by try & error — but keep in mind that not every problem needs a hammer ;-) and give feedback. :-)
1. SYNC in 5 Phases
1.1. 🧩 ALIGN – Because Prompting ≠ Planning
Before any code is written, SYNC forces a brutal question:
“Do you even know what you’re building?”
You can’t just dump “make a task service” into a prompt and hope for gold.
SYNC requires:
-
A verifiable problem
-
Clear, measurable success
-
Known facts and constraints
-
And a list of what’s missing
Can’t answer those? You don’t get to move on. Period.
This is your project kickoff — minus the vague user stories and JIRA hell.
1.2. 🧠 IDEATE – Think Before You Type (or Prompt)
AI loves jumping to conclusions. SYNC doesn’t let it.
Instead, it:
-
Generates multiple solution paths
-
Scores them on DX, security, maintainability
-
Forces a trade-off decision — backed by facts
No “that looks good” commits. No “vibe-based” engineering.
This is what devs mean when they say “thinking in systems.”
SYNC makes that non-optional.
1.3. 🔧 PROTOTYPE – Generate Code That Doesn’t Suck
Now, and only now, do we code. But not like the usual Copilot fanfare.
Every line must:
-
Follow a verified plan
-
Pass static analysis (max level, no warnings)
-
Enforce DX clarity (no hidden state, no weird side-effects)
-
Respect OWASP, type safety, clean structure, documentation
-
Be reviewed by a
MandateAuditorAgent— think of it as your most paranoid tech lead
SYNC doesn’t care if it works. It cares if it’s safe, readable, and maintainable.
1.4. 🔍 REFLECT – Find the Blind Spots Before They Find You
This is where most AI-based workflows stop. SYNC doesn’t.
It demands:
-
Fact-based reflection
-
Side-effect inspection
-
“WTF checks” (yes, that’s real)
-
Architectural delta analysis
Reflection is how you debug thinking, not just code.
Bad engineering isn’t usually broken — it’s just thoughtless.
This phase catches that before prod does.
1.5. 📚 LEARN – Ship, Review, Codify, Evolve
If you’re not learning across projects, you’re repeating mistakes in cleaner syntax.
SYNC documents:
-
What worked
-
What failed
-
What patterns can be reused
-
What rules need to be tightened
This is where engineering culture is built — not in all-hands, but in feedback loops.
🔁 These 5 phases form a tight feedback loop. No skipping. No guessing. No “just ship it” by default.
2. Agents — SYNC’s Execution Layer
2.1. Specialized Roles, Not Generic Personas
Instead of one LLM trying to “do everything,” SYNC splits responsibility across clear, non-overlapping roles. Each one acts like a focused expert in your dev team.
| Agent | Role / Analogy |
|---|---|
PlannerAgent |
Project Architect – breaks the work into slices, defines scope, constraints, and success. |
ExecutorAgent |
Implementation Dev – takes the plan and codes it with strict adherence to facts, security, and DX. |
ReflectionAgent |
Senior Reviewer – evaluates what was built, finds blind spots, forces systemic improvements. |
KnowledgeSynthesizerAgent |
Staff Engineer / Systems Thinker – extracts reusable patterns, proposes framework evolution. |
MandateAuditorAgent |
Tech Lead / Compliance – blocks progress if rules (e.g. security, verifiability) are violated. |
InteractionAgent |
Team Facilitator / QA – handles human check-ins, verifies clarity, enforces decision checkpoints. |
“We don’t need smarter output — we need clearer ownership.”
✅ These agents represent exactly that. SYNC operationalizes the separation of thinking, building, reflecting, and enforcing.
2.2. Persona Modes
SYNC defines two execution modes for agents:
| Mode | Description |
|---|---|
strict |
No ambiguity. Everything must be verifiable and mandate-compliant before progressing. |
adaptive |
Allows temporary ambiguity but logs it. Prioritizes progress with risk awareness. |
This flexibility is key when working with real humans or messy specs — you can choose how “rigid” the AI behaves.
3. Tasks — By Non-Negotiable Laws
These aren’t style suggestions — they’re enforced constraints. Every phase must comply.
| Mandate | What It Ensures |
|---|---|
Security |
No unvalidated inputs or insecure outputs. Based on OWASP Top 10. |
DX |
Code must be typed, clear, maintainable. Predictable naming. No “magic”. |
StaticAnalysis |
Static-Analysis must pass at the highest level — no known warnings. |
Documentation |
Full CodeDoc coverage using modern syntax. |
Style |
Consistent formatting, whitespace, and layout. Enforced via fixer. |
Verifiability |
All decisions must have traceable, factual reasoning. |
PhaseEnforcement |
You can’t skip steps. Every phase must be explicitly completed or justified. |
SYNC doesn’t assume trust. It requires evidence.
How this works together: e.g.
-
Planning =
PlannerAgent→ Add success criteria to issues. -
Execution =
ExecutorAgent→ Code must pass security + static analysis gates. -
Review =
ReflectionAgent→ Comments require fact-based reasoning. -
Merge =
MandateAuditorAgent→ No merge if DX/security rules violated.
