Essays, case studies, and technical guides on agentic programming 2026-05-08T00:00:00Z https://julien-riel.com/en/ Julien Riel 2026-05-08T00:00:00Z https://julien-riel.com/en/articles/understanding-llms/

Tokens, transformers, context window, system prompt, tools: the conceptual foundations for really understanding how ChatGPT, Claude, or Gemini work. No equations.

2026-05-08T00:00:00Z https://julien-riel.com/en/articles/context-window/

An inventory of the techniques that fill the window, the phenomena that degrade it, the heuristics to master it. And along the way, the most expensive anti-pattern in production agents.

2026-04-12T00:00:00Z https://julien-riel.com/en/case-studies/klarna/

How Klarna's triumphant AI customer-service deployment became a public reversal — and why the hybrid that emerged is the real lesson.

2026-04-12T00:00:00Z https://julien-riel.com/en/case-studies/duolingo/

How Duolingo used AI to transform the content pipeline, the product, and the business model — and what its three-layer architecture teaches about agentic design.

2026-04-09T00:00:00Z https://julien-riel.com/en/case-studies/whoop-coach/

How WHOOP wove artificial intelligence into every screen of its app — architecture, evaluations, and lessons for agentic system design.

2026-04-09T00:00:00Z https://julien-riel.com/en/case-studies/cursor/

How Anysphere built an AI-native code editor by solving three problems simultaneously — latency, context, and suggestion quality.

2026-04-09T00:00:00Z https://julien-riel.com/en/articles/rag/

The full RAG pipeline — chunking, embedding, retrieval, reranking — and the production concerns that separate prototypes from systems that work.

2026-04-09T00:00:00Z https://julien-riel.com/en/articles/multi-agent-architectures/

A practical guide to multi-agent patterns — orchestrator-workers, pipelines, ensembles, and swarms — and where they break.

2026-04-09T00:00:00Z https://julien-riel.com/en/articles/fine-tuning-vs-rag/

Fine-tuning changes how the model thinks. RAG changes what it sees. A practical decision framework for when to use each — and when to use both.

2026-04-09T00:00:00Z https://julien-riel.com/en/articles/evals/

A practical guide to LLM evaluation — code-based checks, LLM-as-a-judge, human review, and how to build an eval suite that catches regressions before they ship.

2026-04-09T00:00:00Z https://julien-riel.com/en/articles/advanced-prompt-engineering/

Patterns that separate prompts that work in demos from prompts that work in production — context management, structured outputs, few-shot engineering, and version control.

2026-04-09T00:00:00Z https://julien-riel.com/en/posts/97-the-bigger-the-project-the-more-you-need-to-stay-in-charge/

The temptation scales with the capability.

2026-04-09T00:00:00Z https://julien-riel.com/en/posts/96-let-the-tests-define-the-contract-then-let-the-assistant-fill-it/

Writing tests before implementation isn't just a quality practice in an AI-assisted workflow — it's a communication protocol.

2026-04-09T00:00:00Z https://julien-riel.com/en/posts/95-keep-a-decision-log-the-assistant-can-reference/

Why did you choose this database over the alternatives? Why is the authentication layer structured this way? Why does this module have this interface rather than the more obvious one? If these deci...

2026-04-09T00:00:00Z https://julien-riel.com/en/posts/94-break-the-project-into-phases-the-assistant-can-complete/

A project described as a single continuous flow is hard to work on with an AI assistant.

2026-04-09T00:00:00Z https://julien-riel.com/en/posts/93-treat-your-claude-md-like-a-hiring-document/

Claude Code reads a `CLAUDE.md` file at the start of every session.

2026-04-09T00:00:00Z https://julien-riel.com/en/posts/92-use-markdown-not-prose-for-specifications/

A specification written as flowing prose is hard to reference, hard to update, and hard to provide as context.

2026-04-09T00:00:00Z https://julien-riel.com/en/posts/91-let-the-assistant-write-the-plan-then-edit-it/

When you're starting a substantial piece of work, ask the assistant to write an implementation plan before writing any code.

2026-04-09T00:00:00Z https://julien-riel.com/en/posts/90-write-the-spec-before-you-write-the-prompt/

For a small task — fix this bug, add this field — the prompt can be the spec.

2026-04-09T00:00:00Z https://julien-riel.com/en/posts/89-large-projects-need-a-document-the-assistant-can-always-read/

On a small task, the context you need fits in a prompt.

2026-04-09T00:00:00Z https://julien-riel.com/en/posts/88-use-the-assistant-to-pressure-test-your-own-ideas/

Before you commit to an implementation approach, describe it to the assistant and ask what could go wrong.

2026-04-09T00:00:00Z https://julien-riel.com/en/posts/87-tell-the-assistant-what-to-preserve-not-just-what-to-change/

Every prompt implicitly asks the assistant to optimize for the goal you stated.

2026-04-09T00:00:00Z https://julien-riel.com/en/posts/86-break-large-tasks-into-prompts-not-just-steps/

A prompt asking for five hundred lines of code is asking the assistant to make dozens of design decisions without knowing which ones you've already made, which ones are constrained by the rest of t...

2026-04-09T00:00:00Z https://julien-riel.com/en/posts/85-when-the-output-is-wrong-fix-the-prompt-before-you-fix-the-code/

When the assistant produces code that isn't quite right, the instinct is to edit the code directly — it's faster, it's familiar, it produces the result you need immediately.

2026-04-09T00:00:00Z https://julien-riel.com/en/posts/84-show-the-assistant-what-good-looks-like-in-your-codebase/

Abstract instructions produce generic code.

2026-04-09T00:00:00Z https://julien-riel.com/en/posts/83-start-your-prompt-with-the-outcome-not-the-method/

\"Refactor this function\" is a method instruction.

2026-04-09T00:00:00Z https://julien-riel.com/en/posts/82-an-ai-pair-programmer-has-no-ego-use-that/

Human pair programming is valuable and comes with friction.

2026-04-09T00:00:00Z https://julien-riel.com/en/posts/81-context-is-a-skill-you-can-improve/

Knowing what context to provide — and how to provide it — is the most leveraged skill in working with an AI coding assistant.

2026-04-09T00:00:00Z https://julien-riel.com/en/posts/80-dont-let-the-assistant-drive-the-architecture/

The assistant is excellent at implementing decisions.

2026-04-09T00:00:00Z https://julien-riel.com/en/posts/79-the-best-use-of-an-ai-assistant-is-the-task-you-were-about-to-skip/

Every codebase has work that everyone knows should be done and nobody does.

2026-04-09T00:00:00Z https://julien-riel.com/en/posts/78-commit-often-so-you-have-somewhere-to-return-to/

Working with an AI coding assistant changes the rhythm of development.

2026-04-09T00:00:00Z https://julien-riel.com/en/posts/77-use-it-to-understand-not-just-to-produce/

The most underused capability of an AI coding assistant isn't code generation — it's explanation.

2026-04-09T00:00:00Z https://julien-riel.com/en/posts/76-the-assistant-doesnt-know-your-codebase-unless-you-show-it/

Every session starts fresh.

2026-04-09T00:00:00Z https://julien-riel.com/en/posts/75-read-every-line-it-writes/

The speed of generation is the trap.

2026-04-09T00:00:00Z https://julien-riel.com/en/posts/74-give-the-assistant-your-constraints-not-just-your-requirements/

\"Write a function that parses this config file\" produces something.

2026-04-09T00:00:00Z https://julien-riel.com/en/posts/73-your-ide-is-now-a-conversation/

The developers who get the least out of AI coding assistants are the ones who use them like autocomplete — they wait for a suggestion, accept it or reject it, and move on.

2026-04-09T00:00:00Z https://julien-riel.com/en/posts/72-the-first-version-should-be-embarrassingly-simple/

Every lasting principle in software has a version of this at its core.

2026-04-09T00:00:00Z https://julien-riel.com/en/posts/71-build-for-the-agent-you-have-not-the-agent-you-wish-you-had/

Every developer working with agents has a gap between the current capabilities of the tools they're using and the capabilities they wish those tools had.

2026-04-09T00:00:00Z https://julien-riel.com/en/posts/70-dont-mistake-fluency-for-understanding/

You can become fluent with agentic systems without understanding them.

2026-04-09T00:00:00Z https://julien-riel.com/en/posts/69-the-field-rewards-generalists-who-go-deep-on-one-thing/

Agentic programming sits at the intersection of software engineering, system design, language and communication, domain expertise, and product thinking.