[A follow up post] : SUNBURST SolarWinds Breach: Crime Scene Forensics #SolarWinds #SUNBURST

o the skill to cultivate isn't "can I prompt AI to build faster?" It's "can I see the underlying structure that will let me build 10 things from 1 foundation?" That pattern recognition, that taste, that architectural vision—still human superpowers. Build your LEGOs wisely. 🧱

The companies winning long-term aren't the ones with the most code. They're the ones whose humans spotted the right abstractions early—then rode those building blocks across every seasonal trend, market shift, and product evolution.

Agentic AI excels at execution within abstractions. Humans excel at choosing which abstractions to build. The engineer who sees that "notifications" and "activity feeds" and "messaging" are all the same abstraction? That's 10x leverage.

That foresight requires: Pattern recognition across domains - Taste about what's essential vs. incidental - Intuition about where markets/tech will evolve - Judgment about what complexity to hide vs. expose This is still deeply human territory.

AI agents can generate code at lightning speed. They can implement patterns you describe. But here's what they can't do yet: recognize which abstractions will pay dividends across 10 different future use cases you haven't imagined.

This is bricolage thinking—the art of working with what you have and recombining it creatively. Fashion brands do this every season. Same silhouettes, new colorways. Disney does it across franchises. Good engineers do it with code. The packaging changes. The core compounds.

Here's the kicker: once you nail the abstraction, the only real cost is packaging. Same authentication system → powers B2C, B2B, enterprise. Same recommendation engine → surfaces products, content, connections. Different seasonality. Different markets. Same foundation.

React components. Unix pipes. REST APIs. Database schemas. Design systems. These aren't just "code." They're compression algorithms for human thought—taking complex problems and collapsing them into reusable, recombinant building blocks.

Think of abstractions like LEGO bricks. Once you've designed the right pieces, you can build infinite variations without reinventing the wheel. The Spotify interface? Just "playlists + shuffle + queue" recombined endlessly across podcasts, audiobooks, and social features.

The best engineers don't write more code. They write better abstractions.And here's why that matters more than ever: good abstractions are compounding assets that pay dividends forever. Thread on why human intelligence still owns abstraction in the age of AI 🧵

Looking forward

an incredible visual of how money is moving around the AI ecosystem

Blog Post :

Full pattern docs: https://t.co/hMpnJjK7Kx Working code: https://t.co/POmUFwzIld Builds on the GEPA implementation from PR #19. Pretty cool to see how the judge's feedback drives prompt evolution.

Cost consideration: this doubles your LM calls (task + judge per evaluation), so budget controls are important. The example uses max_lm_calls to cap it. You can also do hybrid - explicit checks for deterministic stuff, judge for subjective quality analysis.

In the math example, baseline score was 0.14. After GEPA optimization using judge feedback, it jumped to 0.28 (2x improvement). The evolved prompt became way more explicit about tracking quantities, showing all steps, and checking work - all learned from the judge's analysis of

The judge evaluates both correctness AND reasoning quality. This catches issues like: - Right answer with flawed logic (lucky guess) - Wrong answer but valid approach (partial credit) - Skipped steps in reasoning - Conceptual misunderstandings Scoring: 1.0 = both correct 0.7 =

Why this matters: GEPA needs rich feedback to work well, but writing explicit feedback rules for complex tasks is tedious. With an LLM judge, you get detailed analysis automatically. Example judge output: "Student correctly identified multiplication needed. Calculation accurate.

The setup is pretty straightforward - you have three LLMs working together: Task LM: generates answer + reasoning Judge LM: analyzes the quality GEPA Reflection: uses judge feedback to improve the prompt Each one specializes in its role.

Using LLM-as-Judge with GEPA for automatic feedback generation Just added a pattern to DSRs that lets you use an LLM judge to automatically generate rich textual feedback for prompt optimization instead of writing manual rules. cc @LakshyAAAgrawal @zaph0id