The Video Signal

Topic

Software Architecture

All digests tagged Software Architecture

James Moss - Using skills to pay the bills: graduating from solo hacks to a team workflow - DevCon26 thumbnail

· 32:39

James Moss - Using skills to pay the bills: graduating from solo hacks to a team workflow - DevCon26

The talk addresses the challenge of 'skill sprawl'—the uncontrolled proliferation and management of AI coding agent skills within large organizations. While skills are powerful because they encode domain-specific logic into an agent's context, their current lack of standardized versioning, review, and centralized governance creates significant technical debt. The speaker advocates for treating skills as first-class software assets, requiring dedicated practices like decomposition, mandatory registries, automated reviews, and formal lifecycle management (CDLC) to ensure reliability and scalability.

Key takeaways

  1. Manage Skill Sprawl with a Centralized Registry 17:33

    Due to the low barrier to entry for creating skills, organizations face an 'insane amount' of them (2 million+ on GitHub alone). A centralized registry is crucial for visibility, preventing overlap, and ensuring all teams use approved versions. This also helps mitigate non-technical users needing access without requiring full developer seats.

  2. Adopt the Context Development Life Cycle (CDLC) 27:50

    Just as code requires a Software Development Lifecycle (SDLC), skills and context require their own CDLC. Practices like skill reviews, automated testing, and version control must be applied to maintain quality and prevent 'rot' (skills going out of sync with the codebase).

  3. Decompose Skills for Modularity 20:40

    Instead of creating monolithic skills, break complex functionality into smaller, interconnected plugins. This allows agents to activate specific components and makes the skill set easier to maintain and debug.

  4. Enforce Governance via Registries 22:30

    Using a registry provides a single source of truth, allowing organizations to enforce policies (e.g., 'approved skills only,' minimum release age) and integrate security scanning tools like Snyk.

Watch on YouTube Full article

Katie Roberts - Stop Maintaining, Start Evolving: Applying AI-Native Practices to Brownfield Codebas thumbnail

· 28:43

Katie Roberts - Stop Maintaining, Start Evolving: Applying AI-Native Practices to Brownfield Codebas

This talk addresses the challenge of modernizing complex, legacy 'brownfield' codebases—systems that are highly successful but burdened by accumulated technical debt and tribal knowledge. The speaker outlines how to apply AI-Native Engineering practices not for adding new features, but for architectural reclamation. Key strategies include using established patterns like the Strangler Fig Pattern and Branch by Extraction, coupled with structured processes (e.g., creating a 'plan skill') to systematically pay down technical debt while maintaining continuous function.

Key takeaways

  1. AI should be used for paying down technical debt, not adding to it. 17:33

    Autonomous agents deployed without strict guardrails can cause havoc through over-optimization or generating 'dark code,' undermining implicit architectural constraints and creating new hidden technical debt. Safety and bounded scopes are paramount.

  2. Adopt a structured approach to brownfield modernization. 20:05

    Instead of starting with the code, begin by conducting forensic investigations using developer input (eyewitness accounts) and creating objective data visualizations (e.g., value vs. complexity graphs) to identify high-priority areas for improvement.

  3. Prioritize planning over immediate migration. 25:32

    In brownfield environments, the planning phase is critical. Focus on creating a structured roadmap and defining clear contracts (specs) before writing code to ensure the right thing is built.

  4. Use AI-assisted skills for process automation. 26:30

    Implement multi-agent flows ('skills') that automate tasks like generating PRDs from documentation, creating Jira tickets, and performing detailed code mapping. This accelerates development cycles (e.g., reducing 6 months of work to 8 weeks).

Watch on YouTube Full article

How to Go From Data Scientist to AI Engineer (I Did This) thumbnail

· 30:13

How to Go From Data Scientist to AI Engineer (I Did This)

This roadmap guides individuals transitioning from Data Science or Machine Learning into AI Engineering. The core message is that the role shifts focus from statistical modeling in notebooks to becoming a full-stack software engineer capable of building reliable, production-grade AI systems. Key areas covered include closing the software engineering gap (OOP, structured Python projects), mastering LLM backends (FastAPI, Pydantic, Docker), and implementing advanced techniques like Retrieval Augmented Generation (RAG), evaluation (Evals), and guardrails.

Key takeaways

  1. The AI Engineer Shift 0:59

    AI Engineering requires moving beyond Jupyter notebooks to structured Python projects using OOP principles, Git, testing, debugging, logging, and environment management. The focus shifts from pure research to building reliable systems around pre-trained models.

  2. Data Science Advantage 2:00

    Individuals with a DS/ML background have an advantage because they are trained in statistical thinking (distributions, error analysis) which is critical for making non-deterministic LLM outputs reliable in production.

  3. The Importance of Production Backends 5:29

    To build deployable systems, learn to use FastAPI and Pydantic for API creation. Containerization using Docker and persistent data storage with PostgreSQL are essential steps.

  4. Advanced AI Techniques 7:30

    Mastering RAG (Retrieval Augmented Generation) requires understanding vector databases (e.g., using the PGvector extension in PostgreSQL). Furthermore, implementing Evals and Guardrails is crucial for quantifying performance and preventing issues like prompt injection.

Watch on YouTube Full article

Platform Engineering in the age of Generative AI - thumbnail

· 1:02:16

Platform Engineering in the age of Generative AI -

The talk argues that while Generative AI tools significantly accelerate code generation and development speed, they are not a 'silver bullet.' To harness AI effectively, organizations must first establish robust platform engineering foundations. The core focus is on implementing comprehensive 'harnessing'—a system of controls (guides and sensors) that ensure consistent behavior, mitigate security vulnerabilities, and guide agents toward high-quality outcomes. Key strategies include adopting open standards like those from the Aentic AI Foundation, utilizing Spec Driven Development (SDD), and treating the entire development environment as a codified, observable artifact.

Key takeaways

  1. Platform Engineering's Goal: Reducing Cognitive Overload 10:40

    Platform engineering should aim to make it the 'path of least resistance' for developers by building internal mechanisms and golden paths. This reduces cognitive overload, allowing teams to focus on delivering value rather than managing complex compliance, security, or deployment processes.

  2. AI is an Amplifier, Not a Solution 20:00

    Generative AI amplifies existing engineering quality. If foundational practices (like documentation and consistent tooling) are weak, AI will amplify those weaknesses, leading to basic security failures or unreliable code.

  3. The Importance of Agentic Standards 30:00

    The Aentic AI Foundation is establishing open standards (MCP servers, agent MD files, and agent skills) to standardize how agents interact with tools. MCP servers are described as a 'USB-C for AI agents,' providing a standard protocol layer.

  4. Harness Engineering: Controlling the Agent 40:00

    A robust 'harness' is the system surrounding the LLM model. It uses two types of controls: **Feed-forward guides** (anticipating and steering behavior, e.g., Agent MD files) and **Feedback sensors** (observing after action, e.g., linters, unit tests, or an 'LLM as a judge' pattern).

Watch on YouTube Full article

Let's build an AI agent - Phil Nash - NDC Copenhagen 2026 thumbnail

· 49:59

Let's build an AI agent - Phil Nash - NDC Copenhagen 2026

This talk demystifies AI agents by building one from scratch, demonstrating how Large Language Models (LLMs), tools, and memory work together in a continuous loop to achieve goals. The core mechanism involves an agent runtime that orchestrates function calls—allowing the LLM to interact with external systems like file systems or calculators. Advanced concepts covered include the Model Context Protocol (MCP) for standardized tool interaction and 'Skills' for progressive disclosure of capabilities, enabling agents to perform complex tasks like self-refactoring.

Key takeaways

  1. Agent Architecture 17:03

    An agent fundamentally runs tools in a loop to achieve a goal. This process requires an LLM, external tools (functions), and an orchestration layer (the 'harness') that manages the interaction.

  2. The Agent Loop 28:10

    The core agent functionality is implemented in a loop: The model generates function calls $\rightarrow$ The harness executes those functions (awaiting results) $ ightarrow$ The results are fed back to the model for the next step, continuing until the goal is met.

  3. Standardization via MCP 36:00

    The Model Context Protocol (MCP) provides a standardized way for agents to interact with services. It separates concerns into Server components (tools, resources, prompts) and Client components.

  4. Progressive Disclosure with Skills 40:05

    Skills allow for progressive disclosure of capabilities. Instead of loading all tool declarations at once, the agent only loads a skill's header initially and can request more details (resources, scripts) as needed.

Watch on YouTube Full article