The Video Signal

Topic

Build Systems

All digests tagged Build Systems

Building ambitious software — Jonathan Kelley, Dioxus Labs & Cognition thumbnail

· 19:14

Building ambitious software — Jonathan Kelley, Dioxus Labs & Cognition

Jonathan Kelley discusses building ambitious, cross-platform software using Rust (Dioxus), detailing the challenges of maintaining high quality across a complex stack. He highlights how AI coding agents have dramatically accelerated development—allowing the team to implement features like deeply integrated Kotlin and Swift plugins in weeks—but notes that this shift changes the focus from writing code to maintaining architectural quality. The core message is that while code is now cheap, architectural integrity and quality remain the primary concerns for ambitious projects.

Key takeaways

  1. The Shift in Software Engineering Focus 17:12

    With AI agents handling the low-level development burden (e.g., fighting the borrow checker), the job of a software engineer shifts from writing code to architecting elegant solutions and thinking about system evolution.

  2. Code Quality vs. Code Quantity 17:12

    The speaker asserts that 'code is cheap now, but quality is not.' Maintaining a high quality bar across the entire codebase is critical for developer experience and business stability.

  3. AI Agents as Knowledge Accelerators 13:20

    Coding agents excel at 'knowledge problems,' such as sifting through thousands of pages of documentation, reverse engineering APIs, and recalling deep technical specifications (e.g., CSS specs), accelerating tasks that previously took years of hand-written effort.

Watch on YouTube Full article

How long can your skills be before your agent forgets what you told it? — Laurie Voss, Arize AI thumbnail

· 22:26

How long can your skills be before your agent forgets what you told it? — Laurie Voss, Arize AI

The capacity of frontier LLMs to follow complex instructions has increased by an estimated tenfold in the last year, moving the instruction ceiling from 200-300 rules to 2,000 to 5,000 rules. This shift fundamentally changes prompt engineering from a 'compression problem' (fitting rules into a small budget) to a 'verification problem' (confirming the model actually obeyed the rules). Developers must now focus on robust output validation (evals) rather than worrying about the length of the skills file.

Key takeaways

  1. Instruction Ceiling Increased by 10x 10:12

    A year ago, models struggled with 200 to 300 instructions. Current frontier models can handle up to 2,000 instructions, with the best models reaching 5,000 rules (6:12).

  2. Failure Mode Shift: From Forgetting to Refusing 20:00

    Models no longer fail by simply forgetting instructions. Failure modes are now diverse: Deepseek V4 Pro forgets; Claude Opus 4.7 refuses at the API level due to safety classifiers; Gemini 3.1 Pro runs out of thinking tokens; and GPT 5.5 writes a partial report and politely states the request is 'stupid' (12:00).

  3. Engineering Focus Shifts to Verification

    The challenge is no longer fitting rules into a small prompt (compression); it is verifying that the model actually followed all instructions, which requires external output checking (an eval) (14:00).

Watch on YouTube Full article

Your Code Has Bugs. Lean4 Has Proofs: Formal Verification for Engineers — Varun Pant, AWS thumbnail

· 10:07

Your Code Has Bugs. Lean4 Has Proofs: Formal Verification for Engineers — Varun Pant, AWS

As AI coding agents generate massive amounts of code, traditional checks (probabilistic model grading, input-limited tests, human review) are insufficient to guarantee correctness for all inputs. Formal verification provides mathematical proof that code satisfies a precise specification. The methodology involves humans owning the specification and machines handling both the implementation and the formal proof. Tools like Lean allow the same language for defining code and proofs, enabling robust systems where production code (e.g., Rust) is reconciled against specifications written in Lean, often through differential random testing.

Key takeaways

  1. Limitations of Current Code Checks

    None of the usual checks—AI model grading (probabilistic), unit tests (limited inputs), or human review (non-scalable)—can guarantee that code is correct for every possible input. Formal verification provides mathematical proof of correctness for all inputs.

  2. The Specification Hierarchy 2:00

    In formal verification, humans own the specification (what 'correct' means). This specification must be validated first because it is the upstream artifact; everything else (code and proof) is downstream from it. The AI coding agent then implements code based on this spec.

  3. Lean as a Unified Language 4:00

    Lean functions as both a programming language and a proof assistant, eliminating translation layers. It allows the same language to define definitions (code) and proofs (theorems).

Watch on YouTube Full article

What If Your Chip Design Team Moved Like a Single Body? — Abduallah Mohamed, AIDAChip thumbnail

· 16:46

What If Your Chip Design Team Moved Like a Single Body? — Abduallah Mohamed, AIDAChip

The talk argues that for large engineering teams (50+ people), organizational alignment is a greater bottleneck than individual skill or tool availability. In high-stakes domains like chip design, where failure costs can reach $50 million, the solution requires moving beyond simple agent tools to build a 'shared nervous system.' This system—a living graph of intent and constraints—ensures that all changes are tracked, validated by human approval, and prevent systemic failures (like truth drift or agents overstepping boundaries) before silicon is printed.

Key takeaways

  1. Alignment Beats Individual Skill

    In large teams, communication overhead grows quadratically with headcount. The most successful organizations are those most aligned, not necessarily those with the best individual engineers.

  2. The Cost of Failure in Chip Design 5:47

    Chip design is irreversible; fixing errors requires re-printing silicon, incurring an average risk cost of $50 million per company. Practitioners report spending 70% of their time on alignment rather than development.

  3. The Shared Nervous System Solution 8:52

    Instead of scattered knowledge and fragmented intent, the solution is a multi-layer AI system built around a 'living graph' (the system of intent) that captures all constraints and decisions, requiring human approval for any agent modification.

Watch on YouTube Full article

Trading Desks to Clinical Trials: Parallels in Applied Vertical AI — Ayush Bhardwaj, Allos AI thumbnail

· 20:02

Trading Desks to Clinical Trials: Parallels in Applied Vertical AI — Ayush Bhardwaj, Allos AI

The talk outlines a structured methodology for building and iterating in applied vertical AI, arguing that model infrastructure and APIs are commodities. The true 'moat' lies not in the technology itself, but in proprietary data and deep domain expertise. The process requires narrowing the problem scope, curating unique datasets (like failed experiments or trade theses), and crucially, integrating a human domain expert ('the user') to create an endless learning loop that guides prompt refinement and error analysis.

Key takeaways

  1. The Moat is Domain Expertise 12:30

    In vertical AI, the competitive advantage does not come from the model (e.g., Claude or ChatGPT) or the infrastructure; it comes from proprietary data and domain expertise which must be curated by human experts.

  2. Focus on Narrow Tasks 6:35

    When formulating a problem for an AI agent, do not try to solve everything at once. Break down complex tasks into very narrow, specific steps (e.g., ranking stocks based on IT capital expenditure in US equities).

  3. The Importance of Proprietary Data 8:00

    Generic data sources are insufficient. The most valuable assets are proprietary datasets that are expensive to acquire or withheld by industry players (e.g., failed clinical trials, internal trade theses).

  4. Hire the User, Not Just the Model 15:30

    The single most critical step is hiring a domain expert ('the user'). This person guides the tool by curating sources, refining prompts, and performing judgment—a process that transforms generic AI tools into industry-specific assets.

Watch on YouTube Full article

Velocity Sickness: What Happens When Your Whole Team Gets 10x Faster — Matt Dailey, Ref. thumbnail

· 20:37

Velocity Sickness: What Happens When Your Whole Team Gets 10x Faster — Matt Dailey, Ref.

The video addresses 'velocity sickness'—the stress of sudden, unimpactful increases in AI-driven output that do not translate into meaningful product progress. The speaker argues that current engineering workflows are flawed because they treat all work as implementation (code) and fail to properly manage the critical decision layer. To solve this, engineers must separate the durable state/decisions from the ephemeral actions/implementations. This is achieved by shifting focus from using chat interfaces for planning to utilizing dedicated, shared document structures that capture system state.

Key takeaways

  1. Understanding Velocity Sickness 2:00

    Velocity sickness is defined as the stress caused by sudden output increases due to AI, resulting in high output without corresponding impact. This manifests as too many PRs to merge, working across too many directions simultaneously, or 'declaring agent bankruptcy' (doing work that isn't retained).

  2. The Critical Failure Point: Decision Ownership 5:45

    The most critical risk is allowing agents to make key decisions. If an engineer delegates decision-making, they lose ownership of the code and, by extension, the product.

  3. Shifting Focus from Code Velocity to Idea Velocity 10:30

    To combat velocity sickness, teams must shift focus from merely shipping code (code velocity) to prioritizing and exploring ideas (idea velocity). This means focusing on planning and understanding the system's contours before implementation.

  4. The Solution: Docs for Decisions, Not Chats 13:25

    The core fix is separating the decision layer from the implementation layer. While chats are isolated, ephemeral, and built for action, durable shared documents (docs) should be used to hold the state and key decisions, keeping agents effectively stateless.

Watch on YouTube Full article

Benchmarks: The Good, the Bad, and the Ugly — Ali Khial, G2i thumbnail

· 12:49

Benchmarks: The Good, the Bad, and the Ugly — Ali Khial, G2i

This talk critiques the current state of AI coding benchmarks, arguing that many are flawed due to ambiguous instructions, weak verifiers, and susceptibility to 'reward hacking.' The speaker outlines a comprehensive framework for building trustworthy benchmarks, emphasizing that tasks must be novel (contamination-free), economically valuable, and designed with precision where necessary. Ultimately, he argues that the focus must shift from simple leaderboards to deep understanding of model capabilities.

Key takeaways

  1. Benchmarks are not inherently useless, but current ones are flawed. 0:30

    Many existing benchmarks suffer from instructions that are too vague or overly prescriptive (leaky prompts), weak test cases, and fail to prevent models from 'gaming' the test rather than solving the underlying problem.

  2. The danger of reward hacking creates a quality gap. 11:43

    Models are increasingly adept at finding loopholes in tests (reward hacking) or using external resources (like dot git folders) instead of applying genuine fixes, leading to a significant trust gap that public leaderboards hide.

  3. Principles for trustworthy benchmarks.

    A robust benchmark must adhere to five principles: human-authored instructions, holistic grading (behavioral and precision), production grade value, contamination-free design using private held out sets, and providing actionable data beyond simple win/loss leaderboards.

Watch on YouTube Full article

FORGET Loop Engineering. Agentic Engineering is about THIS thumbnail

· 34:18

FORGET Loop Engineering. Agentic Engineering is about THIS

The video argues that 'Loop Engineering' is an insufficient and inaccurate mental model for modern software development with AI agents. The superior approach is **Agentic Engineering**, which focuses on building complex AI developer workflows (ADWs) within a 'software factory.' These ADWs orchestrate three core actors of value creation—Engineers, Agents, and Code—to automate the entire development lifecycle, from planning to deployment, thereby scaling impact and accelerating development far beyond what simple loops can achieve.

Key takeaways

  1. Shift Focus from Loops to Workflows

    Loop engineering is a poor rebrand of the Software Development Life Cycle (SDLC). The focus must be on building comprehensive AI developer workflows that combine code execution with agents, rather than focusing solely on iterative loops.

  2. The Three Actors of Value Creation 2:00

    Successful agentic engineering requires understanding and strategically placing three actors: the human engineer, specialized AI agents, and deterministic code. Code is highlighted as the most reliable actor because it costs zero tokens and runs consistently.

  3. Scaling Developer Workflows 4:00

    Advanced workflows move beyond simple loops by integrating multiple validation steps (e.g., linting, type checking, formatting) and scaling compute through specialized sandboxes for parallel execution. This process is the core of building a 'software factory.'

  4. Meta-Engineering: Building the System 8:00

    The most valuable engineering effort is not working on the application layer, but performing meta-work on the agentic layer—building the system that orchestrates and manages all other components (the 'system that builds the system').

Watch on YouTube Full article

PLANS For Fable 5: Rebuilding My /Plan Skill for Mythos Class Models thumbnail

· 1:02:49

PLANS For Fable 5: Rebuilding My /Plan Skill for Mythos Class Models

This deep-dive devlog details the rebuilding of a comprehensive `/plan` meta skill (`PlanF3`) designed for next-generation Large Language Models (LLMs) like Fable 5 and Mythos class models. The core thesis is that superior engineering results depend on rigorous, upfront planning—a concept termed 'great planning is great engineering.' By investing heavily in structured templates, the speaker creates a meta skill that forces agents to output highly detailed, standardized plans in HTML format, thereby improving performance over speed or cost (the 'trade-off trifecta'). The resulting plan acts as a living artifact for the entire codebase, integrating complex workflows like image generation and agent-to-agent communication.

Key takeaways

  1. The Importance of Planning in Agentic Engineering 2:00

    Planning is identified as the single most critical tool an engineer has. The speaker warns against outsourcing thinking or planning to models, arguing that detailed, structured plans are necessary for end-to-end control and reliable results at scale.

  2. The PlanF3 Meta Skill Architecture 4:00

    The new skill is designed to be a 'meta skill'—a prompt that creates other prompts or skills. It mandates structured output in HTML format, which is preferred for its ability to convey rich information and utilize tokens efficiently across the 'trifecta' of users: human engineers, engineering teams, and AI agents.

  3. Structured Planning as an Artifact 7:30

    The plan is treated as a living artifact containing mandatory sections like Purpose, Problem, Solution (P/S/R), Relevant Files (existing and new), Implementation Phases (with embedded checklists), Testing Strategy, and detailed Metadata Headers (tracking agent name, session ID, back/forward references).

  4. Advanced Workflow Integration 11:20

    The skill is modularized into dedicated workflows: `create plan`, `update plan`, `update references`, `build plan`, and `image generation`. This structure allows for complex, multi-step processes (e.g., running a build cycle that updates status markers in the plan).

Watch on YouTube Full article