Platforms for Humans and Machines: Engineering for the Age of Agents — Juan Herreros Elorza

Juan Herreros Elorza, Team Lead at Banking Circle, argues that the established best practices for building human-centric internal developer platforms (IDPs) are now essential prerequisites for the age of AI coding agents. What was once a frustrating experience for a human developer—navigating tribal knowledge, opaque pipelines, and manual dependencies—is “essentially impossible for a machine.” The rise of AI agents amplifies these pain points, making it imperative to re-evaluate and invest in robust platform engineering.

The Problem: A Tale of Developer Frustration

The talk begins with a relatable story of a new developer trying to deploy their first application. This journey is fraught with inefficiencies:

• Tribal Knowledge: The developer is told to “copy it from there,” relying on an existing but poorly understood pipeline.
• Opaque Failures: The pipeline fails with errors unrelated to the application code, leaving the developer confused.
• Human Dependencies: The developer is forced to seek help from specific individuals in other teams, creating bottlenecks.
• Manual Provisioning: After a successful deployment, the developer realizes they need a database, leading back to a manual request process with long wait times.

This workflow is detrimental to human productivity but represents a complete blocker for an AI agent, which cannot navigate social hierarchies or ambiguous, undocumented processes.

Principles for AI-Ready Platforms

The core of the talk outlines concrete practices to build platforms that serve both humans and machines effectively.

1. Self-Service: Both humans and their agents must be able to provision resources and trigger actions autonomously. This process should be intuitive and automated, removing dependencies on specific people.

2. API-Based Interaction: Platforms should expose their capabilities through well-defined APIs. This is critical for agents because APIs are:

   • Discoverable: Agents can programmatically learn what actions are available.
   • Schema-Validated: Ensures that requests are correctly formed, reducing errors.
   • Secure: Incorporate authentication and authorization to manage permissions.
   • Iterative: Enable a request-response loop that allows an agent to try, fail, and adapt until it succeeds. Abstractions like CLIs or Machine-Composable Platform (MCP) servers can be built on top of these APIs.

3. Local-First Development: Since agents often run on a local machine, the platform must “shift left.” Provide tools for local validation to catch errors as early as possible, rather than waiting for a CI pipeline to fail minutes later. This facilitates the rapid iteration loop essential for agent productivity.

4. Structured Documentation & Context: Agents require clear, machine-readable instructions.

   • Centralized, API-Accessible Docs: Instead of just HTML pages, provide documentation via an API so agents can fetch the specific information they need.
   • Agent-Specific Instructions: Use files like agent.md or CLAUDE.md to provide repository-specific instructions on how to build, test, deploy, and verify changes.
   • Skills: Codify common conventions and workflows into reusable markdown “skills” that guide the agent’s behavior for specific tasks.

5. Observability for Agents: Humans use dashboards to verify success, but agents cannot. Observability data—logs, metrics, traces—must be exposed through an API. This allows an agent to programmatically verify that its task was completed successfully, thus “closing the loop.”

AI-Powered Contributions and Measuring Success

AI agents lower the barrier for developers to contribute back to the platform itself. While this accelerates development, it’s a “double-edged sword,” as the platform team remains responsible for maintenance. To manage this, a combination of guardrails is needed:

• Hard Guardrails: Use policies to enforce security, compliance, and architectural standards.
• Soft Guardrails: Use context files (agent.md, skills) to guide contributors on the correct way to build and submit changes.

To validate these efforts, it’s crucial to measure the impact. Track metrics before and after implementing changes. Key areas to measure include:

• Application Delivery: DORA metrics (Lead Time, Deployment Frequency, etc.).
• Reliability: Error rates and system performance.
• Platform Health: Number of support requests, developer satisfaction (e.g., using the SPACE framework).

Final Takeaway

The presentation concludes with a powerful strategic recommendation: use the current industry-wide focus on AI as a lever to champion and implement the engineering best practices that were always valuable but may have been previously de-prioritized. Making your platform ready for AI is not about a radical new paradigm but about a disciplined execution of proven platform engineering principles.

• Tags:
• AI Agents
• Platform Engineering
• DORA Metrics
• Feature
• Observability
• Developer Experience
• API Design
• Internal Developer Platform (IDP)
• Self-Service
• Local-First Development
• Machine-Composable Platform (MCP)