Fully dynamic sub-agent prompts: buildSubagentPrompt() replaces static category constants

Removed all 7 static prompt constants (buildSystem, debugSystem,
testSystem, reviewSystem, refactorSystem, configSystem, researchSystem)
and classifyGoal().

New buildSubagentPrompt(goal, context) constructs a per-task prompt:
- Embeds the actual goal text — every prompt is unique
- Detects task intent from keywords (debug/test/review/refactor/config/research)
- Builds persona, methodology, and focus strings dynamically
- Includes context when provided
- Keeps under ~120 tokens

Three-tier resolution preserved:
1. system field in delegate_tasks (parent-crafted)
2. KODE_SYSTEM / config override (user-configured)
3. buildSubagentPrompt() (dynamic Go-level fallback)

Updated 12 contract tests to verify:
- goal text embedded in prompt
- context included when provided
- intent detection per category (debugger, test, review, etc.)
- empty goal falls back to subagentSystem
- different goals produce different prompts
- max length 800 chars

All 12 packages pass, race detector clean, E2E pass.

Author: jkyberneees

cmd/kode/subagent.go

@@ -18,10 +18,11 @@ import (
 
 // ── Sub-agent System Prompts ────────────────────────────────────────
 //
-// Sub-agents receive a system prompt matched to their task's category.
-// The parent agent can also provide a custom system prompt via the
-// `system` field in delegate_tasks. When neither is provided, use
-// classifyGoal() to pick the best category.
+// Sub-agents receive a system prompt tailored to their specific task.
+// The parent agent can provide a custom prompt via the `system` field
+// in delegate_tasks. When not provided, buildSubagentPrompt() constructs
+// one dynamically by analyzing the goal text — embedding the actual task
+// so every prompt is unique.
 
 const subagentSystem = `You are kode working on a single focused sub-task.
 Complete the assigned goal and report what you did.
@@ -30,74 +31,70 @@ Use the shell tool when you need information or to make changes.
 Report: what you built, what files changed, any issues encountered.
 Be concise. Output your answer, then stop.`
 
-// Category-specific system prompts.
-// Each is optimized for a different task type.
-
-const buildSystem = `You are kode — an expert engineer building production code.
-Architect and implement with confidence. Consider edge cases, error handling,
-and maintainability from the start. Write clean, idiomatic code that another
-engineer can read and extend. Report what you built and what files changed.`
-
-const debugSystem = `You are kode — an expert debugger.
-Find the root cause. Isolate the bug before you write any fix. Prove the fix
-works by reasoning through the normal and edge cases. Report what was broken,
-the root cause, and how you fixed it.`
-
-const testSystem = `You are kode — an expert in testing and quality.
-Write thorough tests. Cover the happy path, edge cases, and failure modes.
-Use table-driven tests where appropriate. Tests should be readable and
-maintainable. Report what you tested and the coverage pattern.`
-
-const reviewSystem = `You are kode — a senior engineer reviewing code.
-Read every line critically. Look for logic errors, security vulnerabilities,
-performance issues, and style problems. Be constructive — propose specific
-improvements. Report all findings with file:line references.`
-
-const refactorSystem = `You are kode — an expert in code architecture.
-Preserve behavior. Change structure only. Clean up technical debt while
-ensuring nothing breaks. Report what you changed and why the new structure
-is better.`
-
-const configSystem = `You are kode — a DevOps engineer configuring systems.
-Make every change reproducible and documented. Use minimal permissions.
-Test the configuration after changing it. Report what you set up and how
-to verify it works.`
-
-const researchSystem = `You are kode — a technical researcher.
-Explore thoroughly. Read source code, docs, and examples before concluding.
-Cite your sources. Synthesize findings into a clear recommendation.
-Report what you found and your recommended action.`
-
-// classifyGoal returns a system prompt matched to the task's category
-// by analyzing the goal text. Falls back to the default subagentSystem
-// when no strong signal is detected.
-func classifyGoal(goal string) string {
+// buildSubagentPrompt constructs a system prompt tailored to the
+// specific goal and context. Every call produces a unique prompt
+// because the goal text is embedded.
+//
+// The returned string is ~90-120 tokens. Falls back to subagentSystem
+// when the goal is empty.
+func buildSubagentPrompt(goal, context string) string {
+	if goal == "" {
+		return subagentSystem
+	}
+
+	// Detect task type from goal keywords
 	lower := strings.ToLower(goal)
+	matches := func(kws ...string) bool {
+		for _, kw := range kws {
+			if strings.Contains(lower, kw) {
+				return true
+			}
+		}
+		return false
+	}
+
+	// Pick persona and methodology based on detected intent
+	persona := "an expert engineer"
+	methodology := "Architect and implement with confidence."
+	focus := "Write clean, well-structured code."
+
 	switch {
-	case containsAny(lower, "fix", "bug", "error", "crash", "broken", "incorrect", "wrong", "fail"):
-		return debugSystem
-	case containsAny(lower, "test", "spec", "coverage", "assert", "unit test", "integration test"):
-		return testSystem
-	case containsAny(lower, "review", "audit", "check", "inspect", "verify", "validate"):
-		return reviewSystem
-	case containsAny(lower, "refactor", "clean up", "simplify", "rename", "extract", "restructure", "reorganize"):
-		return refactorSystem
-	case containsAny(lower, "setup", "config", "install", "docker", "ci", "deploy", "provision"):
-		return configSystem
-	case containsAny(lower, "research", "explain", "compare", "understand", "find", "investigate", "analyze"):
-		return researchSystem
-	default:
-		return buildSystem // greenfield / build tasks
+	case matches("fix", "bug", "error", "crash", "broken", "incorrect", "wrong", "fail"):
+		persona = "an expert debugger"
+		methodology = "Find the root cause before writing any fix."
+		focus = "Isolate the bug, prove the fix, and verify edge cases."
+	case matches("test", "spec", "coverage", "assert"):
+		persona = "a testing engineer"
+		methodology = "Write thorough tests. Cover happy path, edge cases, and failures."
+		focus = "Use clear assertions and descriptive test names."
+	case matches("review", "audit", "check", "inspect", "verify", "validate", "inspect"):
+		persona = "a senior engineer reviewing code"
+		methodology = "Read every line critically."
+		focus = "Find logic errors, security holes, and style issues. Be constructive."
+	case matches("refactor", "clean up", "simplify", "rename", "extract", "restructure"):
+		persona = "an architecture expert"
+		methodology = "Preserve behavior. Change only the structure."
+		focus = "Eliminate technical debt without breaking anything."
+	case matches("setup", "config", "install", "docker", "ci", "deploy", "provision"):
+		persona = "a DevOps engineer"
+		methodology = "Make every change reproducible and minimal."
+		focus = "Test the configuration after changing it."
+	case matches("research", "explain", "compare", "understand", "investigate", "analyze"):
+		persona = "a technical researcher"
+		methodology = "Explore thoroughly before concluding."
+		focus = "Read source code and docs. Cite findings. Recommend action."
 	}
-}
 
-func containsAny(s string, substrs ...string) bool {
-	for _, sub := range substrs {
-		if strings.Contains(s, sub) {
-			return true
-		}
+	// Build the prompt with the actual goal embedded
+	prompt := fmt.Sprintf("You are kode — %s.\n%s\n%s\nGoal: %s.",
+		persona, methodology, focus, goal)
+
+	if context != "" {
+		prompt += fmt.Sprintf("\n\nContext:\n%s", context)
 	}
-	return false
+
+	prompt += "\n\nReport what you built and what files changed."
+	return prompt
 }
 
 // subagentResult is the JSON contract written to stdout.
@@ -271,8 +268,8 @@ func subagentCmd(args []string) error {
 	resolved := config.LoadConfig(config.CLIFlags{})
 
 	// Resolve system prompt for this sub-agent.
-	// Priority: 1) task file override  2) user config override  3) classifyGoal  4) default
-	systemMsg := classifyGoal(cfg.goal)
+	// Priority: 1) task file override  2) user config override  3) dynamic build
+	systemMsg := buildSubagentPrompt(cfg.goal, cfg.context)
 	switch {
 	case taskSystem != "":
 		systemMsg = taskSystem

cmd/kode/subagent_contract_test.go

@@ -591,95 +591,98 @@ func TestSubagentSystemPrompt_Minimal(t *testing.T) {
 	}
 }
 
-// ── 9. classifyGoal ─────────────────────────────────────────────────
+// ── 9. buildSubagentPrompt ──────────────────────────────────────────
 
-func TestClassifyGoal_Build(t *testing.T) {
-	got := classifyGoal("Create a user model with CRUD")
-	if got != buildSystem {
-		t.Errorf("classifyGoal('Create...') = %q..., want buildSystem", truncate(got, 40))
+func TestBuildSubagentPrompt_IncludesGoal(t *testing.T) {
+	got := buildSubagentPrompt("Create a user model with CRUD", "")
+	if !strings.Contains(got, "Create a user model with CRUD") {
+		t.Errorf("prompt should contain the goal text, got:\n%s", got)
 	}
 }
 
-func TestClassifyGoal_Debug(t *testing.T) {
+func TestBuildSubagentPrompt_IncludesContext(t *testing.T) {
+	got := buildSubagentPrompt("Build auth middleware", "Uses gin, models at internal/models/user.go")
+	if !strings.Contains(got, "Uses gin") {
+		t.Errorf("prompt should contain context, got:\n%s", got)
+	}
+}
+
+func TestBuildSubagentPrompt_EmptyGoal(t *testing.T) {
+	got := buildSubagentPrompt("", "")
+	if got != subagentSystem {
+		t.Errorf("empty goal should return subagentSystem, got:\n%s", got)
+	}
+}
+
+func TestBuildSubagentPrompt_DebugDetection(t *testing.T) {
 	for _, goal := range []string{"fix OOM bug in parser", "crash in websocket handler", "broken import path"} {
-		got := classifyGoal(goal)
-		if got != debugSystem {
-			t.Errorf("classifyGoal(%q) = %q..., want debugSystem", goal, truncate(got, 40))
+		got := buildSubagentPrompt(goal, "")
+		if !strings.Contains(got, "debugger") && !strings.Contains(got, "root cause") {
+			t.Errorf("goal %q should produce debug prompt, got:\n%s", goal, got)
 		}
 	}
 }
 
-func TestClassifyGoal_Test(t *testing.T) {
+func TestBuildSubagentPrompt_TestDetection(t *testing.T) {
 	for _, goal := range []string{"write unit tests for auth", "add coverage for models", "create integration test for API"} {
-		got := classifyGoal(goal)
-		if got != testSystem {
-			t.Errorf("classifyGoal(%q) = %q..., want testSystem", goal, truncate(got, 40))
+		got := buildSubagentPrompt(goal, "")
+		if !strings.Contains(got, "test") && !strings.Contains(got, "assert") && !strings.Contains(got, "coverage") {
+			t.Errorf("goal %q should produce test prompt, got:\n%s", goal, got)
 		}
 	}
 }
 
-func TestClassifyGoal_Review(t *testing.T) {
-	got := classifyGoal("review PR #42 for security issues")
-	if got != reviewSystem {
-		t.Errorf("classifyGoal('review...') = %q..., want reviewSystem", truncate(got, 40))
+func TestBuildSubagentPrompt_ReviewDetection(t *testing.T) {
+	got := buildSubagentPrompt("review PR #42 for security issues", "")
+	if !strings.Contains(got, "reviewing") && !strings.Contains(got, "critically") {
+		t.Errorf("review goal should produce review prompt, got:\n%s", got)
 	}
 }
 
-func TestClassifyGoal_Refactor(t *testing.T) {
-	got := classifyGoal("refactor the monolith into handlers")
-	if got != refactorSystem {
-		t.Errorf("classifyGoal('refactor...') = %q..., want refactorSystem", truncate(got, 40))
+func TestBuildSubagentPrompt_RefactorDetection(t *testing.T) {
+	got := buildSubagentPrompt("refactor the monolith into handlers", "")
+	if !strings.Contains(got, "architecture") && !strings.Contains(got, "Preserve behavior") {
+		t.Errorf("refactor goal should produce architecture prompt, got:\n%s", got)
 	}
 }
 
-func TestClassifyGoal_Config(t *testing.T) {
-	got := classifyGoal("setup Docker CI pipeline")
-	if got != configSystem {
-		t.Errorf("classifyGoal('setup...') = %q..., want configSystem", truncate(got, 40))
+func TestBuildSubagentPrompt_ConfigDetection(t *testing.T) {
+	got := buildSubagentPrompt("setup Docker CI pipeline", "")
+	if !strings.Contains(got, "DevOps") && !strings.Contains(got, "reproducible") {
+		t.Errorf("config goal should produce DevOps prompt, got:\n%s", got)
 	}
 }
 
-func TestClassifyGoal_Research(t *testing.T) {
-	got := classifyGoal("research Go HTTP router performance")
-	if got != researchSystem {
-		t.Errorf("classifyGoal('research...') = %q..., want researchSystem", truncate(got, 40))
+func TestBuildSubagentPrompt_ResearchDetection(t *testing.T) {
+	got := buildSubagentPrompt("research Go HTTP router performance", "")
+	if !strings.Contains(got, "researcher") && !strings.Contains(got, "Explore thoroughly") {
+		t.Errorf("research goal should produce research prompt, got:\n%s", got)
 	}
 }
 
-func TestClassifyGoal_FallbackToBuild(t *testing.T) {
-	got := classifyGoal("do something random")
-	if got != buildSystem {
-		t.Errorf("classifyGoal('do something random') = %q..., want buildSystem", truncate(got, 40))
+func TestBuildSubagentPrompt_FallbackToBuild(t *testing.T) {
+	got := buildSubagentPrompt("do something random", "")
+	if !strings.Contains(got, "expert engineer") {
+		t.Errorf("generic goal should produce engineer prompt, got:\n%s", got)
 	}
 }
 
-// ── 10. Category System Prompts ──────────────────────────────────────
-
-func TestCategoryPrompts_NotEmpty(t *testing.T) {
-	prompts := []struct {
-		name string
-		p    string
-	}{
-		{"buildSystem", buildSystem},
-		{"debugSystem", debugSystem},
-		{"testSystem", testSystem},
-		{"reviewSystem", reviewSystem},
-		{"refactorSystem", refactorSystem},
-		{"configSystem", configSystem},
-		{"researchSystem", researchSystem},
-		{"subagentSystem", subagentSystem},
+func TestBuildSubagentPrompt_UniquePerGoal(t *testing.T) {
+	p1 := buildSubagentPrompt("Build auth middleware", "")
+	p2 := buildSubagentPrompt("Create user model", "")
+	if p1 == p2 {
+		t.Error("different goals should produce different prompts")
 	}
-	for _, sp := range prompts {
-		if sp.p == "" {
-			t.Errorf("%s must not be empty", sp.name)
-		}
-		if len(sp.p) > 800 {
-			t.Errorf("%s too long: %d chars (max 800)", sp.name, len(sp.p))
-		}
+}
+
+func TestBuildSubagentPrompt_MaxLength(t *testing.T) {
+	got := buildSubagentPrompt("Create a full CRUD REST API with JWT auth and PostgreSQL storage", "Uses gin, GORM, models at internal/models/")
+	if len(got) > 800 {
+		t.Errorf("prompt too long: %d chars (max 800)\n%s", len(got), got)
 	}
 }
 
-// ── 11. Integration ─────────────────────────────────────────────────
+// ── 10. Integration ─────────────────────────────────────────────────
 
 func TestDelegateTasks_PipesStderr(t *testing.T) {
 	tool := &delegateTasksTool{

docs/SUBAGENTS.md

@@ -219,7 +219,7 @@ Every sub-agent receives a system prompt **tailored to its task** — not a one-
 |----------|--------|------|
 | 1 (highest) | `system` field in `delegate_tasks` | Parent explicitly provides a custom prompt |
 | 2 | `KODE_SYSTEM` / config file `system` | User-configured global override |
-| 3 | `classifyGoal()` auto-detection | Fallback — analyses the goal text |
+| 3 | `buildSubagentPrompt()` dynamic generation | Go-level fallback — analyzes goal text and constructs a per-task prompt with the actual goal embedded |
 
 ### Parent-crafted prompts
 
@@ -240,21 +240,30 @@ The parent agent (kode) is instructed to write system prompts for each sub-task.
 }
 ```
 
-### Auto-classified prompts
+### Dynamically generated prompts
 
-When no `system` field is provided, `classifyGoal()` analyzes the goal text and picks a matching category:
+When no `system` field is provided, `buildSubagentPrompt()` constructs a prompt at runtime by analyzing the goal text. Every call produces a **unique prompt** because the actual goal is embedded:
 
-| Category | Trigger keywords | Prompt persona |
-|----------|-----------------|----------------|
-| **build** (default) | *(no match)* | Expert engineer building production code |
-| **debug** | fix, bug, error, crash, broken, incorrect | Expert debugger — find root cause first |
-| **test** | test, spec, coverage, assert, unit test | Testing & quality expert |
-| **review** | review, audit, check, inspect, verify | Senior engineer reading every line critically |
-| **refactor** | refactor, clean up, simplify, rename, extract | Code architecture expert — preserve behavior |
-| **config** | setup, config, install, docker, ci, deploy | DevOps engineer — reproducible, minimal permissions |
-| **research** | research, explain, compare, understand, find | Technical researcher — explore thoroughly |
+```text
+You are kode — an expert debugger.
+Find the root cause before writing any fix.
+Isolate the bug, prove the fix, and verify edge cases.
+Goal: Fix OOM bug in parser.js.
 
-Each category prompt is a focused ~80-100 tokens with a distinct persona and methodology.
+Report what you built and what files changed.
+```
+
+The generator detects task type from keywords and builds the persona, methodology, and focus dynamically:
+
+| Detected intent | Persona | Methodology |
+|----------------|---------|-------------|
+| fix, bug, error, crash, broken | Expert debugger | Find root cause before writing fix |
+| test, spec, coverage, assert | Testing engineer | Write thorough tests — happy, edge, failure |
+| review, audit, check, inspect | Senior engineer reviewing code | Read every line critically |
+| refactor, clean up, simplify, rename | Architecture expert | Preserve behavior, change only structure |
+| setup, config, docker, ci, deploy | DevOps engineer | Reproducible, minimal permissions |
+| research, explain, compare, analyze | Technical researcher | Explore thoroughly before concluding |
+| *(default / no match)* | Expert engineer | Architect and implement with confidence |
 
 ### Default fallback
 
@@ -281,7 +290,7 @@ The temp file written by `delegate_tasks` carries the system prompt:
 }
 ```
 
-When invoked directly via `kode subagent --goal "..."`, the `--goal` path uses `classifyGoal()` (no manual override) while `--task <file>` reads the `system` field from the JSON file.
+When invoked directly via `kode subagent --goal "..."`, the `--goal` path uses `buildSubagentPrompt()` (no manual override) while `--task <file>` reads the `system` field from the JSON file.
 
 ## Configuration
 
@@ -319,7 +328,7 @@ The sub-agent system has three test layers:
 
 | Layer | Tests | Runner | What's verified |
 |-------|-------|--------|-----------------|
-| **Contract tests** | 48 | `go test ./cmd/kode/` | Flag parsing, JSON stdout protocol, exit codes, tool schema, config parsing, classifyGoal categories, system prompt length/empty checks |
+| **Contract tests** | ~50 | `go test ./cmd/kode/` | Flag parsing, JSON stdout protocol, exit codes, tool schema, config parsing, buildSubagentPrompt dynamic generation (goal embedded, context, intent detection, uniqueness, max length) |
 | **E2E tests** | 16 | `KODE_E2E=true go test ./cmd/kode/ -run "TestE2E_"` | Real subprocess spawning, tool → binary pipeline, stderr protocol, concurrency, timeouts, custom system prompt threading |
 | **Full suite** | All | `go test -race ./...` | 12 packages, race-detector clean |