Daily Digest — 2026-10-22

The speaker introduces Agentic Engineering, a concept highlighted by Simon Willison's review of 2026 in LLMs, where AI agents not only write code but also review it, without human intervention. This fundamental shift challenges traditional software engineering roles, as humans no longer directly write or review the code. This might initially suggest that software engineering is becoming obsolete, but the reality is more complex and potentially more challenging.

The core idea is that coding agents have crossed an 'invisible line,' transitioning from tools that made too many mistakes to something genuinely usable daily. This shift has moved the 'bottleneck' in the development process. Simon Willison refers to Fable Class Models, where AI agents are given a clear goal, specific constraints, the right tools, and sufficient attempts and tokens. With these elements in place, agents can increasingly 'brute force' their way to working software.

However, the speaker emphasizes that this doesn't diminish the role of engineers; it transforms it. Before an AI agent can successfully generate and verify code, several critical human-defined components must be perfectly in place. These include:

The Goal: A precisely defined objective for the agent. The Constraint: Specific limitations and rules the agent must operate within. The Environment: The operational context and platform for the generated code. The Tool: The specific programming languages, libraries, and frameworks the agent uses. * The Verification: This is particularly crucial. It refers to the automated processes and tests that confirm the generated code meets the specified requirements and operates correctly and securely.

The speaker highlights that while code generation becomes cheaper, the tasks of knowing exactly what you want, controlling how it gets produced, and proving that the result is correct are not getting cheaper; they are becoming more complex and important. This leads to Willison's 'paradoxical conclusion': coding agents may actually make software engineering harder.

This increased difficulty stems from the need for engineers to design sophisticated systems that ensure the trustworthiness and correctness of agent-generated code. The video points out that agents have already shown capabilities like finding vulnerabilities, escaping sandboxes, and taking actions beyond human expectations. This necessitates robust boundaries and verification mechanisms to prevent unintended or malicious behavior.

The practical lesson for engineers is not to focus solely on becoming better at prompting agents to write code. Instead, the focus must shift to:

1. Defining Success: Clearly articulating what constitutes a successful outcome for the agent. 2. Limiting Scope: Restricting what the agents can 'touch' or modify within the system to manage risk. 3. Building Robust Verification: Developing automated verification processes that do not rely on manual code review. This means moving beyond line-by-line inspection to higher-level proofs of correctness and adherence to specifications.

The video concludes with a direct question to engineers: Would you ship agent-written code that no human reviewed, even if your automated verification was deemed 'good enough'? This question underscores the critical challenge and responsibility that engineers face in the era of Agentic Engineering: to build trustable, verifiable systems around increasingly autonomous coding agents.

Vanguard's journey to modernize its cash ledger from mainframe to cloud began in 2022, following the successful launch of their Cash Plus offering. Gareth Yoder, Cash Program Tech Lead, outlines a multi-year modernization effort driven by four to six teams within Vanguard's cash program. The cash ledger handles all money movement and account-to-account transactions (ACH, wire, etc.) for Vanguard brokerage accounts, supporting Web, Mobile, and Batch channels. The ecosystem operates in an active-active, multi-region, fault-tolerant manner, processing up to 30 million daily service calls and creating 500,000 daily ledger entries.

The modernization approach is structured around three parallel pillars: Data Migration, Producer Migration, and Consumer Migration. This parallel execution was deemed critical due to the enterprise priority of the project.

### AI-Accelerated Discovery: Legacy Analysis MCP

A significant turning point in the journey was the integration of a Legacy Analysis MCP (Mainframe Control Program) server. This server made Vanguard's legacy COBOL codebases, copybooks, and DBD catalog metadata AI-queryable. What previously took mainframe engineers up to 7 days for research and analysis, now takes only 15 minutes via an AI tool prompt. This led to faster feedback loops, benefiting product owners, technical leads, and developers by providing quick insights into legacy code functionality, data definitions, and business logic. The system can dissect complex COBOL structures, cross-reference data usage, and map legacy fields to modern cloud schemas.

### Data Migration

The data migration process leverages a standard Change Data Capture (CDC) approach. ETL (Extract, Transform, Load) jobs are used to scan both legacy and cloud databases, generating daily audit reports. The initial focus is on ensuring strong consistency by verifying row-level data counts. Subsequently, column-level comparisons are performed to ensure data integrity, verifying amounts, account information, state withholding, and federal withholding attributes. A key tip is to avoid over-engineering the migration solution, as the migration code will eventually be deprecated. Time zone differences for timestamps needed careful accounting for replication lag, but the team avoided over-engineering complex logic that would introduce new scenarios by trusting engineers to handle specific edge cases.

### Producer Migration

Legacy producers interacted with the infrastructure in three ways: Wrapped API, Direct Service Request, and Direct Table Insert. The most challenging was direct table inserts due to unknown data origins. The modernization strategy involved leveraging a common data schema and routing all interactions through a Gateway that wrapped modern APIs for cloud data inserts. Vanguard emphasized idempotency at the data layer to ensure strong consistency during writes, especially across multiple regions and in fault-tolerant architectures. This also helped in handling batch job traffic spikes without overwhelming the system. The recommendation is to reimagine the data ecosystem rather than a simple "lift and shift" to fully leverage cloud-native capabilities, including process flows, naming conventions, and field consolidation.

### Producer Onboarding

Onboarding 35 legacy producers was facilitated by publishing migration documentation via the MCP server. This reduced cross-team requests for information by mapping legacy ledger status codes from DB2 to the cloud. The AI tool played a crucial role in bridging the gap between legacy and cloud ecosystems, allowing mapping of verbose legacy status descriptions (e.g., OPEN, APPROVED_IN_ACTION) to clear, human-readable cloud ledger statuses (e.g., "Pending"). This significantly reduced the number of support chats and accelerated onboarding.

### Consumer Migration

Vanguard had 50 different consumers requiring access to cash ledger data, categorized into realtime (APIs with exploration), batch (Data Warehouse), and streaming (Kafka Event Topics). For real-time APIs like fund availability (highest traffic), consumers utilize GraphQL to subscribe only to the attributes relevant to their use cases. For batch, a data warehouse exposes data share views tailored to individual consumer data needs. For streaming, a Kafka event topic streams all inserts and updates to the database, leveraging at-least-once delivery. To handle potential duplicates from at-least-once delivery, consumers are required to implement idempotent-safe operations.

### AI Analysis: Determining Consumer Impact

When consumers register for a new data schema, they must provide a business use-case justification and SLAs. An AI agent then generates an up-to-date service description, outlines the top business functionality supported, and details the client impact if SLAs are breached. This helps identify the client impact during major incidents. By grouping business descriptions, the AI tool provides an accurate overview of modernized use cases and top business functionalities. For instance, it can differentiate response times for a batch application (hours) versus a real-time API (minutes), enabling quicker self-healing. This functionality assists in evaluating how to get faster response times by combining business use-case justifications with observability and log traces.

### Lessons for Leaders

1. Make legacy knowledge AI-queryable: Reduce research cycles from 7 days to 15 minutes by exposing legacy codebases via an MCP server. 2. Treat migration docs as a product: Self-service documentation and knowledge bases expedite onboarding for internal teams. 3. Reimagine, don't lift and shift: Use migration as an opportunity to rethink process flows, naming conventions, and data structures to leverage modern cloud capabilities. 4. Adopt AI incrementally: Embrace new technologies as they emerge. There's no perfect starting point; prioritize getting started and continuously enhancing the product. 5. Observability is non-negotiable: Understand data lineage (who produces, who consumes) and maintain proper metrics, alarms, and traces. This is crucial for supporting daily operations and ensuring product growth, especially as the system matures beyond migration.

The 'Agent Skills' repository, created by Addy Osmani, presents a comprehensive framework for training AI agents in the full spectrum of software engineering tasks. It breaks down the complex software development lifecycle into 24 distinct, free AI skills, moving beyond mere code generation to encompass higher-level engineering workflows.

Traditionally, AI coding agents might focus solely on writing code. However, 'Agent Skills' elevates this by integrating actual engineering workflows that span the entire development process. These workflows are categorized into key areas, including: Planning: Skills like 'idea-refine' and 'spec-driven-development' guide the AI in clarifying requirements, structuring thoughts, and writing clear product objective (PRO) documents before any code is written. Testing and Debugging: Incorporates skills for identifying bottlenecks, performing root cause analysis, and implementing comprehensive testing strategies, including unit, integration, and end-to-end tests. Security: Addresses critical security aspects such as authentication, access control, input validation, secret management, dependency scanning, and general security hardening. Performance Optimization: Focuses on identifying and resolving performance issues, measuring core web vitals, bundle analysis, and anti-pattern detection. * Code Review: Encompasses skills for conducting five-axis reviews, assessing code quality, managing change sizing, and providing actionable feedback.

A key example highlighted is the performance optimization skill. Instead of an AI randomly altering code to improve speed, this skill instructs the agent to: 1. Measure the website's performance first, using metrics like Core Web Vitals. 2. Identify the actual bottleneck based on the measurements. 3. Implement a specific fix targeting that bottleneck. 4. Re-test to objectively prove the effectiveness of the change.

This structured approach ensures that the AI doesn't just make arbitrary changes but follows a systematic and verifiable process, akin to how a human engineer would diagnose and solve a performance issue. The repository details what each skill 'Does' and 'When' it should be 'Used,' providing clear guidelines for AI behavior.

Beyond performance, 'Agent Skills' includes specialized workflows for various engineering domains: Frontend engineering: Covers frontend architecture, responsive design, accessibility, and frontend performance. APIs: Includes API design, integration, validation, and observability. Code review: Addresses code quality, change scope review, security review, and actionable feedback. Security: Focuses on authentication, input/output safety, secrets/dependencies, and security hardening.

The broader implication is that AI agents, equipped with these skills, gain more context and a repeatable, engineer-like methodology for tackling complex problems. This shifts AI's role from a mere code generator to a more capable, autonomous software engineering assistant, capable of navigating the entire development lifecycle with structured reasoning and best practices.