DEV Community: Niklas Beinghaus

Less, But Better: Dieter Rams' Design Principles for Platform Engineering in the Agentic AI Era

Niklas Beinghaus — Thu, 16 Apr 2026 11:15:27 +0000

In the late 1970s, Dieter Rams looked at the world and saw what he called "an impenetrable confusion of forms, colours and noises." He responded with ten principles of good design. They were written for physical products, but they've outlasted most of the products themselves.

Now look at platform engineering in 2026. Nearly 90% of enterprises run internal developer platforms. AI agents are getting RBAC permissions and resource quotas. MCP has over 10,000 published servers under Linux Foundation governance. Agent2Agent protocols handle distributed orchestration. FinOps is merging with GreenOps.
We are surrounded by an impenetrable confusion again, just a different kind: tools, protocols, agents, abstractions, all piling up faster than anyone can evaluate them.

Rams asked himself:

Is my design good design?

Platform engineers should steal that question!

The Principles, Translated

1. Innovative, but never for its own sake

Rams said innovation must develop in tandem with technology, never as an end in itself.
The MCP ecosystem, A2A protocols, AI-powered golden paths: adopt them where they solve real delivery pain. A platform that integrates MCP to replace dozens of bespoke API adapters is doing real work. One that adds an MCP layer to an internal tool three people use, just to be "agentic," is chasing fashion. I see the second pattern more often than I'd like.

2. Useful, as in, actually usable

A product is bought to be used. Can a developer go from zero to production on a Golden Path without filing a ticket? Can an AI agent provision a staging environment through an MCP tool with the same governance guardrails?
If you're not treating your platform as a product, with developers as customers, you're not doing platform engineering yet. Evan Bottcher wrote this in 2018. The DORA reports have confirmed it every year since. It still isn't obvious to everyone.

3. Aesthetic: elegant abstractions

Aesthetics in platforms isn't about your portal's colour scheme. It's the Terraform module that provisions a compliant namespace in 12 lines. The CI/CD template that works out of the box. The MCP tool schema clear enough that an agent discovers and invokes capabilities without extra prompting.
A Golden Path that requires 47 environment variables is not a path. It's a labyrinth.

4. Understandable, to humans and agents

Rams designed products that talked to you. The physical form communicated the function without a manual.
Platforms now serve two completely different cognitive models: developers who navigate through portals and docs, and AI agents who navigate through structured schemas and tool definitions. MCP exists because the old approach, where every model-to-tool combination needed a custom integration, didn't scale. The protocol makes the platform talk to agents the same way Rams' designs made a radio talk to its owner. That's not a metaphor. That's what self-describing interfaces do.

5. Unobtrusive: enable, don't dictate

The platform exists to enable, not to micromanage. Golden Paths should be the easiest route, not the only route. Guardrails should prevent catastrophe (public S3 buckets, production deploys without tests) without policing every architectural choice.
An agent with RBAC so restrictive that it needs human approval for every single operation isn't an autonomous agent. It's a chatbot with extra steps.

6. Honest: deliver what you promise

This one haunts every team that marketed a "self-service" portal that still requires three Slack messages to get anything done. Or shipped "AI-powered infrastructure" that turned out to be a ChatGPT wrapper around the docs.
AI-generated Terraform that passes linting but omits IAM restrictions is dishonest platform output. AI didn't eliminate the work. It shifted it from writing configs to validating them. An honest platform acknowledges that shift and builds the validation tooling to match.

7. Long-lasting: stable interfaces over trending tools

Rams' 606 shelving system was designed in 1960 and is still in production. It was built around timeless constraints (gravity, wall space, human reach), not around 1960s aesthetics.
Build on durable abstractions. MCP now sits under the Agentic AI Foundation at the Linux Foundation, with Anthropic, Google, Microsoft, AWS, and OpenAI as backers. Open governance is the best signal of longevity we have for a protocol. Put your investment into the interfaces between components, not the implementations behind them. Implementations get replaced. Good interfaces survive.

8. Thorough: nothing left to chance

Does your error message tell the developer what went wrong and how to fix it, or does it dump a stack trace? Does your MCP tool response include structured error codes, or unstructured text that breaks the agent's reasoning chain? Does your policy-as-code make non-compliant deployments technically impossible, or just discouraged?
In regulated industries like finance, healthcare, or fiscal technology, this isn't about quality polish. Compliance baked into the infrastructure layer is the whole reason the platform exists.

9. Environmentally friendly: cloud waste is environmental waste

Rams talked about environmental responsibility before it was mainstream. In 2026, the FinOps Foundation treats Cloud Sustainability as a core capability. Dashboards show dollar costs and carbon emissions next to each other.
Data centers generate emissions on the scale of the aviation industry. But here's the useful part: eliminating an idle VM or rightsizing a cluster that's twice the size it needs to be cuts your bill and your carbon footprint at the same time. Teams that schedule flexible workloads (training runs, batch jobs) during renewable energy peaks are already doing this at scale.
Every idle resource is waste. Every overprovisioned cluster is pollution. But that's the platform team's problem to solve through better defaults, not the developer's problem to solve through extra approval steps. Rams didn't ask the radio buyer to think about energy efficiency. He designed it in.

10. As little design as possible

Every 2026 prediction adds responsibilities to the platform team: agent governance, MCP, ML pipelines, FinOps, security-by-design, carbon tracking. The temptation to build a maximalist platform that does all of it is real.
Rams would say: weniger, aber besser. Less, but better.
The best platforms don't have the most features. They have the right feature at the right moment, and everything else stays invisible. An MCP server should expose the smallest useful set of tools. A governance policy should enforce the fewest constraints that actually keep things safe.
The Braun ET 66 calculator has exactly the controls it needs. Every button earns its place. Your platform service template should meet the same bar.

Quick reference

#	Rams	Platform Translation
1	Innovative	Adopt MCP, A2A, AI agents only where they solve real pain
2	Useful	Serve all personas: devs, SREs, AI agents, compliance
3	Aesthetic	Clean abstractions, consistent interfaces, clear schemas
4	Understandable	Self-describing for both humans and AI agents
5	Unobtrusive	Opinionated defaults with room for autonomy
6	Honest	Real self-service, transparent SLAs, honest AI boundaries
7	Long-lasting	Stable interfaces over trending implementations
8	Thorough	Helpful errors, automatic compliance, nothing arbitrary
9	Env. friendly	Green defaults baked in: efficient regions, rightsized templates, auto-scale-down
10	As little as possible	Fewest capabilities that solve the most important problems

The organizations that will build the best platforms in 2026 are not the ones adopting the most tools. They're the ones that pick the fewest tools that solve the most important problems, and then execute well.

weniger, aber besser

Sources

Dieter Rams: Ten Principles for Good Design — Vitsœ
Platform Engineering in 2025: What Changed, AI, and the Future of Platforms — platformengineering.org
10 Platform Engineering Predictions for 2026 — platformengineering.org
What I Talk About When I Talk About Platforms — Evan Bottcher, martinfowler.com
The 2026 MCP Roadmap — David Soria Parra, Model Context Protocol Blog
Linux Foundation Announces the Agentic AI Foundation (AAIF) — Linux Foundation
Cloud Sustainability — FinOps Foundation Framework

I Built an MCP Server for KubeCon EU 2026: Here's How AI Agents Can Plan Your Conference

Niklas Beinghaus — Thu, 05 Mar 2026 11:00:33 +0000

KubeCon + CloudNativeCon Europe 2026 has 500+ sessions across 4 days, dozens of evening parties, 16 co-located events, and a venue the size of a small airport. Planning your week is a project in itself.

So I built an MCP server that lets AI assistants do it for you.

What's MCP?

Model Context Protocol is an open standard that lets AI models call external tools. Think of it as giving Claude (or any compatible agent) the ability to search databases, call APIs, and interact with real-world data — instead of just working from its training data.

What kubecon-eu-mcp Does

It exposes 12 tools, 4 resources, and 5 prompts that connect your AI assistant to live KubeCon data:

Session tools:

search_sessions — find talks by keyword, speaker, topic, or track
get_schedule — full schedule for any day
find_speaker — look up what someone is presenting
score_sessions — get personalized session rankings based on your role and interests (scoring rubric from kubecon-event-scorer)
detect_conflicts — check if your top picks overlap

Party tools:

find_parties — discover evening events scraped from conferenceparties.com
plan_party_route — optimized party-hopping route through Amsterdam

Logistics:

get_venue_info, get_hotel_info, get_travel_info — venue rooms, hotel blocks, transit from Schiphol, airline discount codes

Data comes live from the official sched.com iCal feed and conferenceparties.com, with in-memory TTL caching.

Try It

uvx kubecon-eu-mcp

Add to Claude Desktop (claude_desktop_config.json):

{
  "mcpServers": {
    "kubecon-eu-mcp": {
      "command": "uvx",
      "args": ["kubecon-eu-mcp"]
    }
  }
}

Then just ask naturally:

"What AI talks are on Wednesday?"
"Plan my evening on Tuesday — I want food and networking"
"Build me a 4-day itinerary as an SRE interested in eBPF and observability"
"Are there conflicts between the sessions I picked?"

The Meta Angle

KubeCon EU has a co-located event called Agentics Day: MCP + Agents on Monday — focused entirely on the Model Context Protocol and AI agents in cloud-native.

So yes, this is an MCP server to help you plan your attendance at the MCP event. We've achieved recursion.

How It's Built

The stack is intentionally simple:

Python with FastMCP (the official MCP Python SDK)
httpx for async upstream fetching
icalendar for parsing sched.com's iCal feeds
BeautifulSoup for scraping party listings
Pydantic for data validation

No database. No config files. Everything is fetched live and cached in memory. Install it, run it, done.