Act of Intelligence

Ajay Medury, Andrew Sierota
  • 5.0 (1)
  • Noticias tecnológicas

Act of Intelligence is a podcast where a software engineer (Ajay Medury) and systems engineer (Andrew Sierota) trade honest, in-the-trenches notes on building real things with AI — the tools, the workflows, and the philosophy — to figure out which old engineering wisdom still holds and which new instincts to trust.

Episodios

  1. hace 5 días

    From NASA to Digital Handyman: Choosing How Much to Trust Your AI

    What does it take to stop babysitting your coding agents? Ajay and Andrew open with how big-tech office politics quietly manage people out, then get into the real news: Luxwander finally has a true progress number (95%), and the workflow that made it measurable has been split out into Rigr — a spec-first system with assurance tiers that let you dial expected quality from NASA-grade down to digital handyman. Along the way: a Minecraft server with a physical gold economy, why front-loading specifications kills a hundred rounds of code review, parallel CI as the new agentic bottleneck, the multi-repo versus monorepo argument, and a closing debate on whether today's models are intelligent or just acting. In this episode: How people get managed out, and what an IC can move without authority Luxwander at 95 percent, and what a real progress bar took Minecraft Nations: guilds, territory, and a physical in-game gold economy Assurance tiers: matching AI effort and cost to the stakes of the job Rigr: specs, slices, and contracts before a line of code is written Parallel CI, multi-repo orchestration, and the monorepo debate Are we the intelligent ones, or is the AI acting? Chapters: (00:00:00) - Teaser: launch a rocket on tier five (00:00:18) - Office politics and how people get managed out (00:06:37) - What an IC can actually move without authority (00:07:42) - Luxwander at 95%: finally a real progress number (00:10:36) - From "just build it" to eighteen modules (00:11:52) - Minecraft Nations: guilds, territory, a physical gold economy (00:19:28) - Assurance tiers: NASA at one, digital handyman at five (00:25:39) - Why Rigr got split out of Luxwander (00:31:39) - Zooming out to an orchestration layer over the agents (00:38:30) - Front-loading specs to kill a hundred rounds of review (00:40:55) - Modules, slices, contracts, and isolation (00:51:16) - Parallel CI becomes the agentic bottleneck (01:00:25) - Multi-repo orchestration and the monorepo argument (01:06:23) - Opinionated defaults, and why design stays human (01:08:43) - Tier thought experiments: rockets and cancer screening (01:10:58) - Are we the intelligent ones?

  2. 13 jul

    The Software Engineering Loop: Contracts, Observability, and Knowing When to Modularize

    Ajay and Andrew start with a cat-induced re-recording and end somewhere they did not expect: the first real "yes" to the show's core question. In between they dig into the software engineering loop, why contracts and modularization make AI-assisted work parallelizable, how to tell when a system actually needs to be split up, and why observability and flexibility are the two tenets they will not give up. They compare Codex, Claude, Fable, and GLM in real use, from usage limits and precision to one-shotting and transparent peak-hour pricing, trade notes on adopting the GSD workflow without losing their own, and watch Sonnet 5 debug an AWS permissions rabbit hole on its own. In this episode: Contracts and modularization, and why they make AI-assisted work parallelizable How to tell when a system actually needs to be split up Codex vs. Claude vs. Fable vs. GLM in real, day-to-day use Why observability and flexibility are the two tenets of the loop Adopting a shared workflow without giving up a hand-built one The first real "yes" to the show's question: act, or intelligence? Chapters: (00:00:00) - Welcome (and a cat-induced take two) (00:02:42) - The "software engineering loop": planning and parallelization (00:05:20) - What's a contract? APIs, JSON, and Amazon Bedrock (00:08:04) - Versioning contracts: 1.0 and breaking changes (00:12:09) - Enforcing contracts: validation, CI, and TDD (00:14:39) - Don't modularize too early: velocity as the signal (00:17:23) - Model limits and generosity (and Grok 4.5 lands) (00:20:24) - Codex's precision vs. Claude's fill-in-the-blanks (00:22:39) - Concise vs. detailed, and OpenAI's Sol/Luna/Tara (00:25:30) - Trying GLM from z.ai, and transparent peak-hour pricing (00:32:09) - A bash wrapper to swap models into the Claude harness (00:34:47) - Back to Claude: why Fable wins on efficiency (00:37:07) - Is Fable one-shotting because SWE principles got trained in? (00:38:19) - Sonnet 5 down an AWS SAM permissions rabbit hole (00:42:41) - Observability for coding agents (LangFuse, Braintrust) (00:45:16) - Adopting GSD: hooks, overlap, and what to steal (00:53:03) - Two tenets of the loop: observability and flexibility (00:54:38) - Blind spots, rituals, and what GSD surfaced (01:01:36) - Act or intelligence? The first "yes"

  3. 10 jul

    The Digital Handyman: Claude Code vs. Codex, and the Rise of Bespoke Software

    Ajay and Andrew get pulled off their notes and into a bigger question: as coding assistants get better at running themselves, what is left for us to do? Fresh off a week of hands-on time with Claude Code and Codex, they compare the limits, the harnesses, and the agents that spawn their own agents, then land somewhere surprisingly practical: the age of the "digital handyman," where anyone can build bespoke software for their own life. Along the way they get into the LLM wiki as a second brain, why Anthropic may be out-earning OpenAI on a fraction of the users, whether vibe coding is dead or just getting started, and the closing verdict that the best handyman might be hands off. In this episode: The LLM wiki as a second brain that lives beyond the model's context window Why the harness, not the model, is becoming the real product Anthropic vs. OpenAI, and what "winning on revenue" actually means Guardrails, newbies, and whether the software development lifecycle still matters at home Building your own finance app when Monarch and Plaid keep breaking Codex's "goal" that runs for days, and why the best handyman might be hands off Chapters: (00:00:00) - Welcome: what "Act of Intelligence" is about (00:02:08) - The LLM wiki: a second brain beyond the context window (00:04:36) - How the wiki works: concepts, synthesis, and "runoff" (00:16:35) - A home-OS detour, and modularizing for the human mind (00:26:28) - Claude Code's limits vs. Codex's generosity (00:27:31) - Anthropic vs. OpenAI: revenue on a fraction of the users (00:32:49) - Wrappers over models: the harness is the value (00:34:13) - The desktop app that spawned and reviewed its own agents (00:38:32) - Guardrails, newbies, and "is vibe coding dead?" (00:44:24) - When software isn't a moat (and a billion habit trackers) (00:46:57) - Monarch, Plaid, and rolling your own finance app (00:49:30) - Pillars of Wealth and the home finance assistant (00:52:19) - The digital age of the handyman (00:56:51) - Now you're the product manager (and trimming the tools) (01:03:45) - Codex's "goal": the run that wouldn't stop (01:08:29) - "The best handyman is hands off" (01:11:07) - Opinionated harnesses, and the future they're building (01:14:11) - Mirage or oasis? The close

  4. 30 jun

    AI Coding Is Solved. Software Engineering Isn’t.

    If coding is "solved," is software engineering? Ajay Medury (software engineer) and Andrew Sierota (systems engineer) pick up where Episode 1 left off and get into the part that isn't solved: judgment. They trade notes on why weekly usage limits have quietly become the real project budget, what it's like to build a sharded Minecraft world solo as both product manager and principal engineer, what Amazon's New World got wrong about scale, running decorrelated multi-model code reviews, and what an AI "skill" actually is. It might all just be an act of intelligence. In this episode: Why "coding is solved" but software engineering isn't, and why judgment is the expensive partThe new bottleneck: weekly subscription usage limits as a hard budgetBreaking a big build into modules and submodules, and shrinking scope to actually shipWearing every hat at once: product manager and principal engineerNew World and the problem of scale at launchLarge codebases, heavy test coverage, and review rounds that exposed process gapsPre-flight checks, linters, and spec-tracing that cut review loops downDecorrelated reviews: several different models reviewing blind, then taking the union of findingsWhat an AI "skill" is: system prompts, user prompts, and guardrails for long workflowsSeverity tiers for findings: blockers, warnings, defers, suggestions, and nitsWhy systems admins, as generalists by trade, may be an ideal audience for these tools Chapters: (00:00:00) - Real intelligence, or just an act?(00:01:02) - Coding is solved; software engineering isn't(00:02:02) - Keeping up with the release pace(00:05:27) - Vibe coding vs. a repeatable process(00:06:40) - Usage limits are the new budget(00:08:40) - Breaking the build into modules(00:12:18) - A sharded world, every hat on one builder(00:17:12) - New World and the problem of scale(00:25:04) - 200k lines and a 90-round review(00:27:20) - Pre-flight checks that cut 90 rounds to 5(00:30:49) - The podcast's own local-GPU pipeline(00:33:27) - Learning by asking "what do you mean?"(00:35:35) - When a large agent run burned through the budget(00:38:05) - What is a skill, really?(00:48:05) - Skills as guardrails for long workflows(00:51:09) - Severity tiers: blockers to nits(00:54:34) - Why sysadmins are ideal builders(00:56:29) - A long-running Minecraft community, the real driver(01:00:56) - Closing: an act of intelligence

  5. 3 jun

    Welcome to the Matrix - Pilot

    Welcome to Act of Intelligence — a new podcast about AI tools, workflows, and the philosophy of building with them, hosted by Ajay Medury and Andrew Sierota. In this pilot, a software engineer and systems engineer compare notes on what it's actually like to build real software with AI coding agents like Claude Code. They get into plan mode and context management, the explosion of open-source "memory" tools for Claude, and the build-vs-buy trap of reinventing the wheel. Along the way: why "writing code is a solved problem" but shipping working software isn't, how the job is shifting from coder to technical PM / systems architect, the engineering fundamentals (DRY, modular design, conventions, spec-driven development) that suddenly matter more in the AI era, and a simple rule for how much to trust the machine — let the risk decide. Plus Andrew's first big AI build: resurrecting a decade-old Minecraft community from a 20-page wish list he never had time to finish. It never really ends — but for human sakes, we found a place to stop. Welcome to the Matrix. (00:00) - Intros — meet Ajay & Andrew(01:25) - What Claude Code actually is (a CLI loop)(03:37) - Plan mode vs. "super plan"(05:41) - Clearing context to reclaim your tokens(06:25) - The Claude memory-tool gold rush (claude-mem)(08:40) - "Mem Palace," impostor packages & bubble vibes(11:59) - Build vs. buy: don't reinvent the wheel(14:57) - Why understanding your own project matters(17:56) - "Writing code is a solved problem" — is it?(21:07) - From coder to technical PM / systems architect(22:48) - Modular design: building by "limbs"(25:58) - Validation & the "works on my machine" trap(26:58) - Reviving a decade-old Minecraft community(30:58) - DRY, the factory pattern & CLAUDE.md(36:47) - Conventions & standards files(38:11) - Design tenet: "don't waste the player's time"(39:02) - Reviewing & racing the compactor(39:32) - Spec-driven development ("Get Shit Done")(51:11) - The orchestrator + agent-swarm pattern(54:46) - Do old engineering rituals still apply?(58:15) - Trust should match the risk(59:49) - Wrap-up — Welcome to the Matrix

    Welcome to the Matrix - Pilot
  • 5 episodios

Acerca de

Act of Intelligence is a podcast where a software engineer (Ajay Medury) and systems engineer (Andrew Sierota) trade honest, in-the-trenches notes on building real things with AI — the tools, the workflows, and the philosophy — to figure out which old engineering wisdom still holds and which new instincts to trust.

Información

  • Creador
    Ajay Medury, Andrew Sierota
  • Años de actividad
    2026
  • Episodios
    5
  • Clasificación
    Explícito
  • Copyright
    © 2026 Ajay Medury, Andrew Sierota
  • Mostrar sitio web
    Act of Intelligence