# AIE CODE: OpenAI, ArtCraft, Cognition, Exa, Anthropic, Amp, et al

## Executive summary

The future of software engineering is shifting from writing code to building and engineering systems that write code. Multiple speakers presented models for 'Software Factory Engineering,' defining a factory as a declarative, closed-loop system for continuously measuring and improving AI coding agents. Key technical focus areas include establishing open protocols (MCP/CLI-first), ensuring data integrity in agent outputs (e.g., structured JSON/compact output), and implementing robust CI/CD practices for agentic workflows, such as self-improvement loops and benchmarking.

## Key takeaways

- Ambition and Ownership in AI: True ambition in AI is not about increasing token usage, but about developing the language and critical judgment to describe what 'good' looks like. Developers must maintain ownership of the work, acting as active participants rather than passive observers of AI-generated 'slop.'
- The Workshop vs. The Factory: Focus on building the 'artiller' or 'workshop' (the process and tools) before building the automated 'software factory.' Model improvements (e.g., using the latest models) are dramatically increasing agent capability without requiring changes to the core harness functionality.
- Defining the Software Factory: A software factory is defined as a 'code defined closed loop system for continuously measuring and improving cloud coding agents.' This requires encoding the entire workflow in a declarative language (like Terraform) and establishing continuous measurement and improvement loops.
- Agent Output Reliability and CLI Design: Agents often fail by relying on simple piping (`|`) or assuming the answer's location. To improve reliability, tools must 'fail loudly,' provide structured output (e.g., JSON, compact mode), and expose flags/skills to guide the agent's search process.
- The Importance of Open Protocols and Native Code: To combat proprietary 'extractive' models, the trend is toward open-source, MCP (Micro-Component Protocol) and CLI-first applications. Languages like Rust are favored for their memory safety and ability to deploy natively across multiple platforms.

## Technical details

- Software Factory Architecture: The ideal factory infrastructure stack includes: 1) Factories as Code (declarative definition); 2) Data/Context Layer (recording all agent conversations and artifacts); 3) Compute Layer (sandboxing for security/repeatability); 4) Inference Layer (supporting multiple models/harnesses); 5) Orchestration Layer; and 6) API/MCP-first design (integrating with Jira, GitHub, etc.).
- Agent Improvement Loops: Continuous improvement requires setting up online evals (having one agent score the output of another) and running benchmarks on proprietary data to test model/harness/factory configurations against real-world failure modes.
- Agent Session Data Management: Tools like `tapes.dev` are used to collect and manage agent session data, which serves as the primary source of 'product analytics' for identifying friction points and improving tool design.
- CLI Best Practices for Agents: When designing CLIs for agents, implement features like 'compact mode' (e.g., JSON output) and use specific flags/skills to guide the agent, rather than relying solely on pipes, which can cut critical information.

## Practical implications

- Adopt a 'Factory Engineering' mindset: Treat coding agents as a new engineering primitive and build systems around them, rather than just using them ad-hoc.
- Prioritize open protocols and CLI/MCP-first design to ensure interoperability and prevent vendor lock-in.
- Implement robust measurement capabilities (benchmarking, DORA metrics) and closed-loop feedback systems to continuously improve agent performance and cost efficiency.
- When building tools for agents, focus on structured, predictable output formats (e.g., JSON, compact mode) and teach the agent how to use specific flags/skills to prevent data loss via piping.

## Topics

AI Engineering, Software Architecture, Agentic Workflows, DevOps/CI/CD, Open Source Development, OpenAI, Google DeepMind, Arendelle (PI coding agent), Warp, Artcraft, Rust, MCP (Micro-Component Protocol), Terraform, tapes.dev

Source: https://www.youtube.com/watch?v=y9JtCCZP2MQ
