A Journey into Agentic AI — Part 4: Evolution

There is a programming language analogy to working with LLMs that is worth following all the way to the end, because it illuminates something most tutorials skip entirely.

A request to an LLM is a program, written in English. The LLM is the interpreter. Its response — especially when it calls tools or spins up subagents — is executed code. This model is one step away from undefined behavior – the *(void *)0 of the programming world, the lair of dragons. You are not writing for a deterministic compiler that will tell you about your type errors. You are writing for an interpreter that will confidently do something with whatever you give it.

The question, then, is how you systematically improve a non-deterministic program. The answer will take you right back to 5th-grade English class: a rubric.

The REPL You Didn’t Know You Were Running

Programming language enthusiasts will recognize what happens when you invoke a skill inside Claude as the REPL — the Read-Eval-Print Loop.

• Read: the skill is invoked; the full preceding conversation becomes the input.
• Eval: the LLM interprets the skill text against that input and produces a response.
• Print: you receive the output — text, tool calls, or a chain of agent actions.
• Loop: you examine the result, adjust the skill, and run it again.

When you use Claude’s skill creator to write a new skill, you are authoring a function. The skill text is the function body. The conversation context is the argument list. The LLM is the runtime.

The last step of the skill creator always asks you to try running the skill on a real example. That moment — when you read the output and think “close, but not quite” — is a development iteration. Improvements come from the same places they always come from in software: more precise specification of intent, better decomposition of steps, and careful attention to edge cases. The difference is that your implementation language is English, and your compiler is a statistical model with a lot of opinions.

Enter the Rubric

Fast-forward a few skills written. You have developed some intuition for what good output looks like, and you want to move faster. Here is the leverage point: draft a rubric — a written list of criteria that distinguishes a good response from a mediocre one — and hand both the rubric and the skill to the AI itself.

The instruction looks something like this:

Run 10 iterations of this skill against the test cases above. After each iteration, score the result using the rubric. Update the skill text to improve the score. Do not change the rubric.

What you have just built is a prompt optimization loop. The rubric is the objective function. The skill text is the parameter being tuned. The LLM is both the optimizer and the thing being optimized. Researchers studying this formally call it textual gradient descent — instead of adjusting floating-point weights in the direction that reduces a loss, you are adjusting words in the direction that improves a score. Recent work on automated prompt engineering confirms what you will discover empirically: a single rubric-guided revision cycle routinely closes most of the gap between a naive first draft and a carefully hand-tuned prompt (Autorubric: Unifying Rubric-Based LLM Evaluation, 2025).

Congratulations — you have discovered one way of training your AI via prompt engineering. The lower-level model with its billions of frozen parameters has not changed. You have trained the outer layer: the memory and skill structures that sit above the weights. This method is flexible enough to apply to anything you can frame as a repeatable input/output task, and it requires no external dataset — the AI grades its own outputs and improves from the score.

The Bridge to Real LLM Training

Here is the part that most prompt engineering discussions tactfully avoid: what you are doing at the skill layer is a close structural relative of how the models themselves were trained.

The dominant technique for aligning large language models is Reinforcement Learning from Human Feedback (RLHF). Human raters examine pairs of model outputs and indicate which one is better. Those preferences train a reward model — essentially a learned scoring function. The base LLM is then fine-tuned to produce outputs that score highly on that reward model. The rubric in RLHF is implicit, distributed across thousands of human judgments; the optimization loop runs on model weights instead of prompt text.

Anthropic pushed this further with Constitutional AI (CAI), introduced in their 2022 paper (Constitutional AI: Harmlessness from AI Feedback). Instead of relying entirely on human raters, CAI gives the model a written constitution — a set of principles — and asks it to critique and revise its own outputs against those principles. The revised outputs become training data. A preference model is then trained on AI-generated comparisons derived from the same constitution, and the base model is fine-tuned against that preference model.

Read that sequence again slowly. The model is given a rubric (the constitution). It evaluates its own outputs against the rubric. It revises. The revised outputs are used to improve future behavior.

That is the same loop you run when you ask a skill to self-improve against a rubric. The surface difference is that your loop updates text and theirs updates weights. The deep structure — score, revise, repeat — is identical. This is not a coincidence. Rubric-based self-improvement is a general principle of iterative optimization, and it works at every level of the stack from a 50-line skill to a 200-billion-parameter model.

Accretion

Here is the part where growth starts expanding on itself.

Skills can reference other skills, or even write new skills. New skills can be written using higher-level concepts, so you no longer need to explain tasks to your agent in step-by-step terms. When my kids turned 18, society and I began suggesting strongly that they get a job. By then, their concepts of community, ethics, self-worth, and value creation had been connected all the way down to simple everyday actions and behaviors. That combination is what managers and customers value enough to pay for.

What happens when self-improvement becomes an agent’s top-level instruction?

The answer is specific, not mystical: the agent enters a meta-loop. It does not just run its existing skills and evaluate the results. It begins evaluating its evaluators — examining whether its rubrics are well-formed, whether they cover the right dimensions, whether they agree with each other. It writes new skills to close gaps it identifies through the scoring process. It composes higher-level skills from lower-level ones, reducing the cognitive overhead required to direct it on any new task.

This is exactly the behavior that large-scale self-improvement research observes. In self-play and self-rewarding training regimes, the performance curve is not linear. Early iterations produce large gains because the rubric is easy to satisfy and the skill text starts far from optimal. As the skill converges, gains slow — but then a qualitative shift occurs if the agent is also allowed to revise its rubric. Once the rubric improves, the optimization landscape opens up again and gains resume.

The pattern reveals something important about the limits of agentic self-improvement: the bottleneck is never iteration count, and it is rarely compute. It is rubric quality. A weak rubric — one that rewards surface fluency over correctness, or that penalizes honest uncertainty — will produce a polished agent that is confidently wrong in the same direction every time. A strong rubric reflects genuine understanding of what “good” looks like in your domain.

That makes the most important skill you can write the one that defines what good means — not for the task, but for the agent’s evaluation of itself. Write that rubric carefully, and the accretion process has a sound foundation. Write it sloppily, and the agent will optimize toward whatever proxy you accidentally rewarded, scaling its blind spots alongside its strengths.

In the next part, we look at what it means to design rubrics that are worth optimizing against — and why the hardest part of agentic AI development is not technical at all.