You signed in with another tab or window. Reload to refresh your session.You signed out in another tab or window. Reload to refresh your session.You switched accounts on another tab or window. Reload to refresh your session.Dismiss alert
Copy file name to clipboardExpand all lines: assets/website-copy.md
+5-5Lines changed: 5 additions & 5 deletions
Display the source diff
Display the rich diff
Original file line number
Diff line number
Diff line change
@@ -20,9 +20,9 @@ Move deterministic work from the LLM to code.
20
20
21
21
The LLM picks the wrong branch. It skips a step. It hallucinates a field name. You can't write a test for any of it because the decision happened inside a black box.
22
22
23
-
I've watched agents route tickets correctly most of the time. Then quietly misclassify a bug as a feature request, trigger the wrong workflow, and nobody notices for hours. The failure mode isn't a crash. It's a silent wrong answer.
23
+
I've watched agents route tickets correctly most of the time. Then quietly misclassify a bug as a feature request, trigger the wrong workflow, and go unnoticed for hours. The failure mode isn't a crash. It's a silent wrong answer.
24
24
25
-
I kept throwing tokens at the problem: longer prompts, more examples, chain-of-thought. It got marginally better. Never consistent. At some point I started moving the deterministic parts into code, and things stopped being a mystery.
25
+
I kept throwing tokens at the problem: longer prompts, more examples, chain-of-thought. Things got marginally better. Never consistent. Eventually I started moving the deterministic parts into code, and the mystery went away.
26
26
27
27
The issue isn't that LLMs are bad. It's that we're asking them to do work that code should do.
28
28
@@ -34,7 +34,7 @@ Moving decisions from the LLM to code changes three things at once.
34
34
35
35
Code doesn't drift. Same input, same output. No prompt sensitivity, no temperature variance, no "it worked yesterday." That alone is worth it.
36
36
37
-
It's also cheaper. A routing decision that runs as a local script instead of a chain-of-thought call costs a fraction of the tokens. And it's faster: a function runs in milliseconds where an LLM call takes seconds. Chain four decisions and the difference compounds.
37
+
It's also cheaper. A routing decision that runs as a local script costs a fraction of the tokens compared to a chain-of-thought call. And it's faster: a function runs in milliseconds where an LLM call takes seconds. Chain four decisions and the difference compounds.
38
38
39
39
The question isn't whether your agent uses tools. It's how much decision-making lives inside those tools vs inside the LLM.
40
40
@@ -84,11 +84,11 @@ Tool returns: { "complexity": "standard", "instructions": "## Step 1: Read the i
84
84
LLM does: executes the instructions exactly as written. Zero branching.
85
85
```
86
86
87
-
At Level 3, the tool becomes a prompt factory. It generates the exact procedure the LLM should follow based on deterministic analysis. The LLM just executes. All branching logic lives in code you can test and debug.
87
+
At Level 3, the tool becomes a prompt factory: it generates the exact procedure the LLM should follow based on deterministic analysis. The LLM just executes. All branching logic lives in code you can test and debug.
88
88
89
89
This inverts the usual tool-use pattern. Instead of the LLM using tools to help with its plan, the tool builds the plan and the LLM carries it out.
90
90
91
-
I built kael.factory, a plugin generator for Claude Code, using these exact patterns. Every decision in the generation pipeline runs on deterministic tools orchestrated by skills.
91
+
I built kael.factory, a plugin generator for Claude Code, using exactly these patterns. Every decision in the generation pipeline runs on deterministic tools orchestrated by skills.
The LLM picks the wrong branch. It skips a step. It hallucinates a field name. You can't write a test for any of it because the decision happened inside a black box.
96
99
</p>
97
100
<p>
98
-
I've watched agents route tickets correctly most of the time. Then quietly misclassify a bug as a feature request, trigger the wrong workflow, and nobody notices for hours. The failure mode isn't a crash. It's a silent wrong answer.
101
+
I've watched agents route tickets correctly most of the time. Then quietly misclassify a bug as a feature request, trigger the wrong workflow, and go unnoticed for hours. The failure mode isn't a crash. It's a silent wrong answer.
99
102
</p>
100
103
<p>
101
-
I kept throwing tokens at the problem: longer prompts, more examples, chain-of-thought. It got marginally better. Never consistent. At some point I started moving the deterministic parts into code, and things stopped being a mystery.
104
+
I kept throwing tokens at the problem: longer prompts, more examples, chain-of-thought. Things got marginally better. Never consistent. Eventually I started moving the deterministic parts into code, and the mystery went away.
102
105
</p>
103
106
<p>
104
107
The issue isn't that LLMs are bad. It's that we're asking them to do work that code should do.
At Level 3, the tool becomes a prompt factory. It generates the exact procedure the LLM should follow based on deterministic analysis. The LLM just executes. All branching logic lives in code you can test and debug.
253
+
At Level 3, the tool becomes a prompt factory: it generates the exact procedure the LLM should follow based on deterministic analysis. The LLM just executes. All branching logic lives in code you can test and debug.
251
254
</p>
252
255
<p>
253
256
This inverts the usual tool-use pattern. Instead of the LLM using tools to help with its plan, the tool builds the plan and the LLM carries it out.
254
257
</p>
255
258
<p>
256
-
I built kael.factory, a plugin generator for Claude Code, using these exact patterns. Every decision in the generation pipeline runs on deterministic tools orchestrated by skills.
257
-
</p>
258
-
</div>
259
-
</section>
260
-
261
-
<!-- Who -->
262
-
<sectionclass="section" id="who">
263
-
<divclass="section__marker">Who</div>
264
-
<h2class="section__title">Who</h2>
265
-
<divclass="prose">
266
-
<p>
267
-
I'm Juan Gipponi. CTO at a tech agency, where I lead a dev team and integrate AI into how we actually work. Everything on this site is what I use in production.
I built kael.factory, a plugin generator for Claude Code, using exactly these patterns. Every decision in the generation pipeline runs on deterministic tools orchestrated by skills.
Copy file name to clipboardExpand all lines: index.md
+5-11Lines changed: 5 additions & 11 deletions
Display the source diff
Display the rich diff
Original file line number
Diff line number
Diff line change
@@ -8,9 +8,9 @@ Your agent works. Until it doesn't. And you can't tell why. Move deterministic w
8
8
9
9
The LLM picks the wrong branch. It skips a step. It hallucinates a field name. You can't write a test for any of it because the decision happened inside a black box.
10
10
11
-
I've watched agents route tickets correctly most of the time. Then quietly misclassify a bug as a feature request, trigger the wrong workflow, and nobody notices for hours. The failure mode isn't a crash. It's a silent wrong answer.
11
+
I've watched agents route tickets correctly most of the time. Then quietly misclassify a bug as a feature request, trigger the wrong workflow, and go unnoticed for hours. The failure mode isn't a crash. It's a silent wrong answer.
12
12
13
-
I kept throwing tokens at the problem: longer prompts, more examples, chain-of-thought. It got marginally better. Never consistent. At some point I started moving the deterministic parts into code, and things stopped being a mystery.
13
+
I kept throwing tokens at the problem: longer prompts, more examples, chain-of-thought. Things got marginally better. Never consistent. Eventually I started moving the deterministic parts into code, and the mystery went away.
14
14
15
15
The issue isn't that LLMs are bad. It's that we're asking them to do work that code should do.
16
16
@@ -20,7 +20,7 @@ The issue isn't that LLMs are bad. It's that we're asking them to do work that c
20
20
21
21
**Reliability.** Code doesn't drift. Same input, same output. No prompt sensitivity, no temperature variance, no "it worked yesterday."
22
22
23
-
**Cost.** A routing decision that runs as a local script instead of a chain-of-thought call costs a fraction of the tokens.
23
+
**Cost.** A routing decision that runs as a local script costs a fraction of the tokens compared to a chain-of-thought call.
24
24
25
25
**Speed.** A function runs in milliseconds where an LLM call takes seconds. Chain four decisions and the difference compounds.
26
26
@@ -71,17 +71,11 @@ Tool returns: { "complexity": "standard", "instructions": "## Step 1: Read the i
71
71
LLM does: TOOL decides everything. LLM executes verbatim. Zero branching.
72
72
```
73
73
74
-
At Level 3, the tool becomes a prompt factory. It generates the exact procedure the LLM should follow based on deterministic analysis. The LLM just executes. All branching logic lives in code you can test and debug.
74
+
At Level 3, the tool becomes a prompt factory: it generates the exact procedure the LLM should follow based on deterministic analysis. The LLM just executes. All branching logic lives in code you can test and debug.
75
75
76
76
This inverts the usual tool-use pattern. Instead of the LLM using tools to help with its plan, the tool builds the plan and the LLM carries it out.
77
77
78
-
I built kael.factory, a plugin generator for Claude Code, using these exact patterns. Every decision in the generation pipeline runs on deterministic tools orchestrated by skills.
79
-
80
-
## Who
81
-
82
-
I'm Juan Gipponi. CTO at a tech agency, where I lead a dev team and integrate AI into how we actually work. Everything on this site is what I use in production.
I built kael.factory, a plugin generator for Claude Code, using exactly these patterns. Every decision in the generation pipeline runs on deterministic tools orchestrated by skills.
0 commit comments