The Video Signal

Topic

Build Systems

All digests tagged Build Systems

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