Devops on Simple Enough Blog

What is a Harness for AI Agents? Understanding the Infrastructure Behind Claude Code and Cursor

Wed, 27 May 2026 15:55:01 +0200

I. What is a Harness for AI Agents?

When you first discover tools like Claude Code, Cursor, or OpenAI Codex, it is easy to assume that a simple language model is capable of understanding an entire codebase, fixing bugs, executing commands, and running tests autonomously.

However, the technical reality is far more interesting.

The AI model is often only one piece of the system. Behind these tools lies a much more important layer than it first appears: the harness.

EC2 Checklist: 7 Things to Do After Launching an Instance

Wed, 20 May 2026 19:30:00 +0100

EC2 Checklist: 7 Things to Do After Launching an Instance

Launching an EC2 instance is easy.

A few clicks in the AWS Console, and your machine is running.

In reality, however, a launched instance is not a production-ready instance.

Many production incidents stem from small details that were overlooked immediately after launch:

Misconfigured security groups
No backups
No monitoring
Missing IAM role
Poor SSH configuration
Insufficient storage
Missing tags

Here is a simple and practical checklist of 7 things you should verify immediately after launching an EC2 instance.

Nx Is Not a JavaScript Tool: It Is a Work Orchestrator

Wed, 13 May 2026 12:00:00 +0100

I. Nx Is Not a JavaScript Tool: It Is a Work Orchestrator

Nx is often presented — and perceived — as a JavaScript tool.
“A thing for Angular,” or at best “a monorepo runner for Node.”

That perception is understandable…
but fundamentally incorrect.

Nx is not a JS tool.
Nx is a work orchestrator.

And that is precisely why it appears almost naturally as soon as a repository becomes polyglot.

Introduction to AWS Lambda: the complete guide for beginners and developers

Wed, 06 May 2026 10:00:00 +0100

I. What is AWS Lambda?

AWS Lambda is a serverless compute service launched by Amazon in 2014.
The idea is simple: you provide a function (a piece of code), and AWS runs it on demand, without you having to manage any servers.

You don’t provision servers, you don’t maintain an OS, and you don’t configure autoscaling manually.

Why Is Docker Cache Insufficient for a Monorepo?

Tue, 28 Apr 2026 10:00:00 +0100

I. Why Is Docker Cache Insufficient for a Monorepo?

Docker is everywhere.
And with it, a widely shared idea:

“If we structure our Dockerfiles well, Docker cache will speed up our CI.”

That is true… but only up to a certain point.

As soon as you work in a monorepo — with multiple projects, multiple languages, and multiple logical pipelines — Docker cache quickly shows its limits.

What Should You Really Cache in a CI/CD Pipeline?

Tue, 21 Apr 2026 10:00:00 +0100

I. Introduction

When trying to speed up a CI/CD pipeline, the first idea that almost always comes up is:

“we need to add cache”

But very quickly, another question appears:
what exactly are we caching?

Files? Folders? Docker images? Dependencies?
And above all: which cache has a real impact, and which one just makes the system more complex?

Thinking Top-Down in a Complex World

Tue, 07 Apr 2026 17:30:00 +0100

I. Two Fundamental Ways of Reasoning

When we observe how we design complex systems today — DevOps infrastructures, distributed platforms, modern software, or even educational pathways — we almost always find the same intellectual tension. On one side, there is a progressive and incremental approach, which starts from the basics and moves toward something more elaborate. On the other, there is an outcome-oriented approach, which begins by defining a goal, then works backward to determine what is needed to achieve it.

Everyday Chaos Engineering: Learning to Love the Wave

Tue, 24 Mar 2026 10:00:00 +0100

We all dream of a stable, predictable, “calm” system. And yet, the reality of a modern platform is a living sea: deployments, external dependencies, cloud quotas, flaky networks, traffic spikes, human error—and sometimes… just “something” that should never have happened.

Chaos engineering is often presented as a spectacular discipline—“we cut an AWS zone,” “we kill a cluster,” “we take Kafka down.” In real life (and especially in small teams), that’s neither necessary nor desirable at the beginning.

DevOps Cycle or a Misunderstanding of the Role?

Tue, 17 Mar 2026 11:00:00 +0100

Introduction

The term DevOps is frequently used to describe a heterogeneous set of topics: CI/CD, cloud, Kubernetes, security, observability, incident management, cost management, and more. This breadth of meanings creates a recurring confusion: an organization expresses a need for “DevOps” without specifying the expected value, the associated responsibilities, or the target operating model.

The outcome is well known: a succession of urgent periods, followed by automation initiatives, and then a gradual return to the same difficulties. This is often described as the “DevOps cycle.” In many cases, this cycle is not intrinsic to DevOps itself, but rather the indicator of a misunderstanding of the role: DevOps is used as a compensating function (support, firefighting, implicit ownership of production) instead of as a structuring organizational capability.

The Real Cost of a Bad CI Workflow: Cognitive Load

Wed, 25 Feb 2026 10:00:00 +0100

I. The Real Cost of a Bad CI Workflow: Cognitive Load

People talk a lot about CI pipeline performance.
We measure minutes.
We optimize caches.
We parallelize.

But the real cost of a bad CI workflow is not machine time.

It is cognitive load.

And it is far more expensive.

II. The Invisible Problem

An inefficient CI pipeline is visible:

AWS multi-accounts: architectural solution or disguised organizational debt?

Wed, 18 Feb 2026 17:30:00 +0100

I. Introduction

Creating multiple AWS accounts is now widely presented as a near-universal best practice.
It is often introduced through simple, console-oriented tutorials that give the impression that the problem boils down to a few clicks.

This view is misleading.

Multi-account is not an implementation detail, but a fundamental architectural choice.
It directly impacts:

how teams work,
how security is enforced,
cost visibility,
the ability to automate,
and organizational resilience to human error.

When misunderstood, it creates organizational debt just as costly as traditional technical debt.

Entering the Cloud: The Gates of Hell

Wed, 04 Feb 2026 09:10:00 +0100

Entering the cloud is rarely experienced as a simple infrastructure change.
For many organizations, it is a brutal—almost violent—break with their habits, tools, and mental models.

What was supposed to bring simplicity instead reveals a complexity that had long been hidden.
And this complexity is not only technical.

I. The Call of the Cloud

The cloud always begins with a seductive promise.

Test-Driven Infrastructure: Applying TDD to Infrastructure as Code

Wed, 14 Jan 2026 13:45:30 +0200

Test-Driven Infrastructure

Applying TDD to Infrastructure as Code

Test-Driven Development (TDD) is now well established on the application side.
However, when it comes to infrastructure, many still consider TDD unnecessary, too complex, or unsuitable.

That is a mistake.

TDD applied to infrastructure already exists, often without being named as such. When properly understood, it becomes a major lever for securing, structuring, and evolving a cloud platform.

Using Constants in TDD with Go

Tue, 23 Dec 2025 10:08:49 +0200

Best Practices, Pitfalls, and Design Signals

Test-Driven Development (TDD) is not only about writing tests.
Its primary purpose is to design software.

In Go, the use of constants is often misunderstood in TDD:

should they be exposed?
tested?
injected?
avoided?

This article proposes a pragmatic and idiomatic Go approach, based on real-world experience, to understand when a constant represents good design… and when it hides a deeper problem.

Interfaces, Functions and Modules in Go: Structuring Your Code for TDD Without Adding Unnecessary Complexity

Mon, 15 Dec 2025 10:08:49 +0200

I. Introduction

Go is a minimalist language, but this simplicity can sometimes make developers feel like something is “missing” — especially when dealing with more advanced architectures, Test-Driven Development, or the need to mock dependencies. Developers coming from Java, C#, or Python often ask the same questions:

Should I turn all my functions into structs + interfaces to test them?
How should I organize my packages to keep them modular and testable?
Where should interfaces live — in the provider or the consumer?
How do I isolate a package that only exports functions?
How does Go automatically detect signature changes?

II. Go’s Model: Simple, Modular, but Different

Unlike Java or C#, Go does not rely on inheritance, classes, or heavy dependency injection frameworks.

Consumer-Reported Dependency Health

Mon, 08 Dec 2025 11:18:06 +0200

I. Rethinking How We Evaluate the Health of Distributed Systems

In modern distributed architectures, a system’s health depends as much — if not more — on the state of its dependencies as on its own internal state. Yet most monitoring strategies still rely on synthetic or dedicated healthchecks: /health endpoints, liveness/readiness probes, external scripts, and similar mechanisms.

Why AWS Spot Instances Become Impossible to Get in December

Mon, 01 Dec 2025 17:08:49 +0200

I. Why AWS Spot Instances Become Impossible to Get in December

EC2 Spot Instances are a fantastic way to save 50–70% on your AWS compute costs.
They use the unused capacity of AWS data centers… but in December, this unused capacity almost completely disappears.

Result:

Auto Scaling Groups fail to launch new instances
deployments get stuck
“insufficient capacity” everywhere
Spot interruptions become much more frequent

If you’ve experienced this, rest assured: it’s not your fault, and not a configuration issue.
It’s a seasonal phenomenon, and it happens every single year.

Karpenter: The Intelligent Autoscaler for EKS

Mon, 24 Nov 2025 11:18:06 +0200

I. What is Karpenter?

Karpenter is an open-source autoscaler for Kubernetes, created by AWS.
Its purpose is to automatically adjust the EC2 node capacity of an EKS cluster based on real workload demand.

In short:

When your cluster is short on resources, Karpenter adds new nodes.
When nodes become unnecessary, it removes them.

But more importantly:

It does this faster, more intelligently, and more efficiently than Kubernetes’ traditional autoscaler (Cluster Autoscaler).

This is who IAM

Tue, 27 May 2025 15:33:47 +0200

I. IAM: Core Components and Concepts

IAM is based on entities and policies.

IAM Entities

Users: Represent people or applications. Example: a developer named “alice”.
Groups: Collections of users sharing the same permissions.
Roles: IAM entities that can be temporarily assumed by others. Ideal for federation or services like EC2 or Lambda.
Policies: JSON documents that define permissions attached to an entity.

Sample JSON Policy

{
 "Version": "2012-10-17",
 "Statement": [
 {
 "Effect": "Allow",
 "Action": "s3:ListBucket",
 "Resource": "arn:aws:s3:::example_bucket"
 }
 ]
}

This IAM policy allows an AWS entity (user, role, or group) to list the objects in a specific S3 bucket named example_bucket. It uses the standard IAM version format (2012-10-17) and allows the s3:ListBucket action on the resource identified by its ARN. It lets the entity see the list of objects (names, sizes, metadata), but not read or modify them—unless additional permissions are granted. This minimal policy is often used for inventory or bucket navigation via the AWS Console or API.

3 Simple Ways to Save Up to 90% on EC2 Costs: Spot Instances

Fri, 02 May 2025 17:08:49 +0200

I. Introduction to Spot Instances

Amazon EC2 Spot Instances offer a powerful way to drastically reduce cloud computing costs. Designed to utilize unused Amazon EC2 capacity, these instances are available at a price up to 90% lower than On-Demand instances.

While these savings are appealing, Spot Instances are not suitable for all workloads. They are ideal for flexible, interruption-tolerant, or distributed jobs such as data processing, machine learning training, or performance testing.

A problem. Don’t panic, prepare a support ticket

Fri, 25 Apr 2025 13:10:00 +0100

I. Identify and Reproduce the Problem Precisely

Before contacting AWS Support, it’s crucial to clearly document the observed behavior. The goal is to enable the support team to quickly analyze the context. Start by identifying the service involved: EC2, S3, Lambda, or another component of your cloud infrastructure. Documenting an incident clearly is key to avoiding unnecessary back-and-forth.

Why and how to use Git submodules

Tue, 22 Apr 2025 10:00:00 +0100

I. Introduction to Git Submodules

Git submodules are a built-in feature that lets you include one Git repository inside another. This approach is useful when you need to manage dependencies between different codebases while keeping them autonomous.

Submodules point to a specific commit of an external repository. This ensures that every version of the main project uses exactly the same revision of its submodules, providing consistency and reproducibility.

Introduction to AWS ELB

Sat, 15 Mar 2025 21:11:49 +0000

I. Introduction to Load Balancers in AWS

An Elastic Load Balancer (ELB) acts as a traffic distributor, automatically spreading incoming traffic across multiple target resources such as EC2 instances, containers, or IP addresses.

This functionality is a cornerstone of fault-tolerant and highly available cloud application design. AWS offers three types of ELB tailored to different use cases, each with specific features.

What is a Bundle? Understanding the Concept

Mon, 03 Feb 2025 10:00:00 +0100

The term “bundle” is widely used in web development and DevOps. It refers to a grouping of files, resources, or elements to simplify their management and improve performance.

However, a bundle does not have the same meaning everywhere. In this article, we will explore its different uses in three key areas:

Hugo (static site generator)
CSS & JavaScript (front-end development)
DevOps (Docker, Kubernetes, Helm, etc.)

1. Bundle in Hugo: Organizing Files Smartly

In Hugo, a bundle is a folder containing a page and its associated resources (images, JSON files, etc.). There are two types of Page Bundles: