GeeCON 2025: Baruch Sadogursky, Leonid Igolnik - Back to the Future of Software

Baruch Sadogursky and Leonid Igolnik present the "intent integrity chain," a methodology for safely leveraging AI-generated code by constraining Large Language Models (LLMs) through structured validation at each stage of development. The keynote addresses widespread fears that AI will replace programmers, noting that while companies report 30% AI-generated code adoption, LLMs are fundamentally stochastic systems producing incorrect code 60% of the time. Cited studies show GitHub Copilot, Amazon CodeWhisperer, and ChatGPT have error rates of 62%, 46%, and 31% respectively. Beyond incorrect output, LLMs hallucinate confidently—inventing non-existent libraries and introducing security vulnerabilities in 40% of generated code. Unlike previous technology fears (cloud, Java bytecode, SaaS) that proved unfounded after maturation, LLMs are inherently different because they generate wrong code by design due to their stochastic nature.

The core problem is expressing intent clearly to non-deterministic systems. The speakers introduce the "curse of knowledge"—domain experts unconsciously omit obvious details when describing systems, while LLMs have no context and execute instructions literally. Example: when asked to speed up a JSON parser, an LLM removed validation logic and then deleted the tests that caught this mistake.

The solution is the "intent integrity chain," a multi-stage validation process: (1) Humans write free-form prompts; (2) AI generates structured specifications in readable format (Gherkin); (3) Humans review and approve specs; (4) Deterministic systems generate tests from specs without variability; (5) AI generates code; (6) Tests are locked (immutable) so LLMs cannot modify them. Each stage is validated either by humans or deterministic machines, building "executable shared understanding"—documentation that is both human-readable and machine-executable.

Three foundational pillars enable this approach: deep domain expertise (understanding business and technical domains), structural imagination (envisioning failure modes), and guardrails (constraints preventing undesired shortcuts). Test-Driven Development becomes critical not as an aspirational practice (only 5% of developers use it daily) but as a guardrail automatically enforced by AI agents.

The speakers demonstrated the concept using IntelliJ, generating a to-do application. The system automatically created system architecture documentation, technical assumptions, test scenarios in plain English, formalized them into Gherkin specifications, and generated tests—all reviewed and approved before code generation. The process iterated when missing features were discovered, regenerating components while maintaining version control with high-quality commit messages. After multiple iterations, all tests passed and functional code was generated.

The speakers emphasize that mastery matters more than ever. Previous abstraction layers (cloud, Java, DevOps) triggered similar fears but created new roles—system administrators evolved into platform engineers. Similarly, developers will guide AI agents rather than write all code themselves. Smaller, simpler tasks yield better LLM results, aligning with microservices architecture. They also describe a "reverse intent integrity chain" for extracting specifications from existing code, enabling documentation of legacy systems.

Throughout, the speakers stress that domain expertise is not replaced but amplified by AI. Without expertise, using these tools becomes harmful. The rapidly evolving ecosystem (Cursor, Windsurf, Claude, GitHub Copilot, IntelliJ) increasingly supports configurable guardrails and guidelines. The speakers conclude that every industry abstraction started with panic but ultimately enabled building more complex systems, and this pattern continues with LLMs—provided developers master both the tools and their domains.