Software Engineering
Guides on vibe coding, spec-driven development, testing, databases, Git, and building systems that don't fall over.
New and updatedAll 172 guides
- Which Code Hosting Platforms Ban AI-Generated Code? Codeberg and SourceHut restrict AI-generated code, Stack Overflow bans ChatGPT answers. What each policy says, when it takes effect, and how enforcement works.
- How to Prevent AI Code Detectors From Flagging Your Code AI code detectors flag style, not origin. Learn what makes code look machine-generated, how to write code that doesn't get flagged, and when hiding it is the wrong move.
- What Watermarks Do LLMs Leave in Generated Code? Text watermarks like SynthID-Text and Claude's watermark exist — but code has no deployed watermark yet. Here's how watermarking works and why code resists it.
- Can AI-Generated Code Be Detected? No reliable way to detect AI-generated code exists. Detectors claim high accuracy but mislabel human code and are easy to evade. What actually works instead.
- What Is an AI Agent? An AI agent is a program that uses a language model to decide and act — calling tools, reading files, and iterating until a task is done. Learn how they differ from chatbots.
- What Is Vibe Coding (and Where Does It Break Down)? Vibe coding is building software by prompting AI and accepting what works, without reading every line. Learn what it is and exactly where it fails.
- What Is Spec-Driven Development? Spec-driven development writes a specification before code, so AI agents build from explicit intent. Learn how it fights intent drift and context decay.
- How to Write a Spec an AI Coding Agent Can Actually Follow Write specs that produce reliable AI-generated code: explicit goals, edge cases, non-goals, and acceptance criteria. A practical, template-driven guide.
- What Is Context Engineering? Context engineering is the skill of curating what an AI model sees so it produces the right output. Learn why it's replacing prompt engineering.
- How to Optimize Token Usage When Coding with AI Every AI coding session burns tokens. Learn the five levers that cut token spend 50-80%: prompt compression, caching, model routing, output control, and context pruning. Practical techniques for vibecoders and teams.
- Monolith vs Microservices: Which Should You Start With? For most projects, start with a monolith and split later. Microservices solve scaling and team problems you likely don't have yet. A direct comparison.
- REST vs GraphQL vs gRPC: Which API Style Should You Use? REST, GraphQL, and gRPC each fit different needs: simple HTTP, flexible queries, or high-performance service-to-service calls. A comparison table.
- Self-Hosted AI Coding Models in 2026: The Practical Review The gap between open-weight and proprietary coding models is closing fast. Compare Kimi K3, GLM-5.2, Qwen3-Coder, Gemma 4, DeepSeek V4, and more. Benchmarks, hardware requirements, and honest recommendations for every budget.
- How to Coordinate Multiple AI Coding Agents on One Codebase Running multiple AI agents in parallel sounds fast, but without coordination they overwrite each other's work. Learn six patterns that keep parallel agents safe: spec-driven decomposition, git worktrees, role splits, model routing, verification gates, and sequential merges.
- What Is Database Indexing (and Why Is My Query Slow)? A database index is a lookup structure that lets queries find rows without scanning the whole table. Learn how indexes work and why queries are slow.
- How to Add an Index to a Slow SQL Query Diagnose a slow query with EXPLAIN, add the right index, and verify the speedup. A practical PostgreSQL tutorial.
- How to Choose the Right AI Coding Tool for Your Workflow Compare the 8 best AI coding tools of 2026: Claude Code, Cursor, GitHub Copilot, OpenAI Codex, Windsurf, Gemini CLI, Lovable, and Bolt. Decision guide for vibecoders of every skill level, budget, and project type.
- What Is the N+1 Query Problem? The N+1 problem fires one query per row instead of one query total, and AI-generated ORM code causes it constantly. Learn it with a code example.
- What Is Technical Debt? Technical debt is the future cost of shortcuts taken today — and AI-generated code creates it faster than ever. Learn to recognize and manage it.
- How to Review AI-Generated Code Like a Senior Engineer A practical checklist for reviewing AI-generated code: correctness, security, edge cases, and intent. Review what the assistant skips, not just what it wrote.
- What Is a Code Smell? A code smell is a surface clue that deeper problems lurk in the code — like duplicated logic or a function doing too much. Learn the common smells.
- What Is Test-Driven Development (TDD)? TDD writes a failing test first, then the minimum code to pass it, then refactors. Learn the red-green-refactor cycle and why it matters.
- How to Write Your First Unit Test Write your first unit test in Python with pytest: a real function, a real test, and the red-green cycle. A first-principles tutorial for beginners.
- Unit vs Integration vs End-to-End Tests: What's the Difference? Unit tests check one piece, integration tests check pieces together, and end-to-end tests check the whole user flow. A comparison table.
- What Is Semantic Versioning (SemVer)? Semantic versioning is the MAJOR.MINOR.PATCH scheme that tells consumers what a version change means. Learn how to read and apply it.
- How to Stay Motivated When AI Coding Makes Everything Feel Easy A practical mindset guide for vibecoders: turn the excitement of fast prototypes into a repeatable habit of shipping, checking, and learning.
- Monorepo vs Polyrepo: Which Should You Use? A monorepo holds all projects in one repository; a polyrepo splits them. Compare the trade-offs for sharing code, CI, and team autonomy.
- How to Build a Productive AI Coding Routine Build a repeatable AI coding routine around focused sessions, clean context, small changes, and verification instead of endless prompting.
- How to Write a Good Git Commit Message A good commit message states what changed and why in an imperative, one-line subject. Learn the format that keeps history useful.
- What Is Git Rebase (and When Should You Use It Instead of Merge)? Merge preserves history with a merge commit; rebase replays your commits on top for a linear history. Learn the difference and when to use each.
- How to Recover When an AI Build Gets Messy When repeated AI prompts stop producing progress, reset the project with evidence, a smaller problem, and a deliberate debugging loop.
- How to Resolve a Git Merge Conflict Resolve a Git merge conflict step by step: read the conflict markers, choose the right change, and finish the merge — without losing work.
- How to Think Like an Owner When AI Writes the Code Move from prompt-writer to product owner: use constraints, evidence, security boundaries, and user outcomes to decide what AI-generated software should do.
- How to Build Confidence as a Beginner Using AI Coding Assistants Build real confidence as a beginner with AI coding by collecting evidence, learning one concept at a time, and taking responsibility for a small slice of the project.
- What Is Caching (and the Most Common Ways to Get It Wrong)? A cache stores frequently used data for fast retrieval. Learn how caching works, why it helps, and the classic ways to get it wrong.
- How to Add Redis Caching to Your App Add Redis caching to a Node.js app: cache a slow endpoint, invalidate on writes, and set expiry. A practical, working tutorial.
- How to Learn Software Engineering While Building With AI A practical learning loop for beginners using AI: understand one concept, apply it to a real feature, test it, explain it, and remember the lesson.
- How to Recover When AI Makes a Mistake in Your Code A calm incident playbook for AI coding mistakes: contain the change, preserve evidence, roll back safely, verify the fix, and prevent a repeat.
- What Is Idempotency (and Why Does It Matter for APIs)? An idempotent operation can be retried safely — doing it once or many times has the same effect. Learn why payments and webhooks depend on it.
- The Beginner Vibecoder Playbook: A Weekly Routine for Building With AI A one-page weekly routine for beginner vibecoders: stay motivated, learn deliberately, build confidently, own decisions, verify changes, and recover calmly from mistakes.
- What Is Rate Limiting? Rate limiting caps how many requests a client can make, protecting your API from abuse and overload. Learn the strategies and why you need it.
- How to Add Rate Limiting to an API Add rate limiting to a Node.js API with the express-rate-limit middleware: per-user limits, 429 responses, and retry headers. A working example.
- What Is a Race Condition? A race condition happens when the outcome depends on the timing of concurrent operations. Learn it with a concrete code example and the fixes.
- Why Do .env Files Keep Leaking Secrets? .env files leak because they're easy to commit by mistake and AI assistants have no convention against it. Learn the failure and how to stop it.
- How to Manage Secrets and Environment Variables Properly Store secrets outside your code: environment variables for config, a secret manager for sensitive values, and never commit .env files. A practical guide.
- What Is Multi-Agent Coding (and Why Do Agents Conflict With Each Other)? Multi-agent coding runs several AI agents on one codebase in parallel — and they step on each other's changes. Learn the failure modes and how to manage them.
- What Makes a Codebase "AI-Friendly"? An AI-friendly codebase gives agents clear conventions, modular files, and tests so they make fewer mistakes. Learn the traits that make AI coding work.
- Databases for AI Builders: Why Your AI-Generated App Gets Slow and Loses Data Your AI writes working SQL that fails at scale. Learn indexing, the N+1 problem, transactions, connection pools, migrations, backups, and consistency — with linked guides for each.
- What Should You Actually Look For in a Code Review? A code review checks correctness, security, readability, and tests — in that order. Learn the checklist that catches real problems, not just style.
- Working With AI Coding Agents: The Complete Workflow From Prompt to Production Choosing an agent, writing specs it can follow, reviewing its diffs, and debugging what you didn't write. Every guide in the AI coding workflow, in one place. 30+ linked guides.
- How to Structure a Python or Node.js Project From Scratch A clean project structure for Python and Node.js: separate source, tests, and config, with a layout that scales and that AI agents can navigate.
- Software Engineering for AI Builders: The Concepts Your Coding Assistant Won't Teach You Your AI writes the code, but it doesn't teach you testing, architecture, databases, or Git. Learn every software engineering concept you need to go from vibecoding to shipping. 45+ linked guides.
- What Is the Twelve-Factor App Methodology? The Twelve-Factor App is a set of principles for building portable, cloud-native software — from config in the environment to stateless processes.
- How to Work With an AI Coding Assistant Without Creating a Mountain of Tech Debt AI assistants generate code fast — and generate tech debt faster. Duplicated logic, dead code, over-engineered abstractions. Here's the system for catching these before they accumulate: review, deduplicate, simplify, delete.
- How to Stop AI Assistants from Duplicating Code Across Your Project AI assistants can't see your entire codebase, so they duplicate validation, formatting, and helper functions everywhere. Here's how to find duplication, extract shared code, and prevent the AI from copying itself again.
- How to Find and Remove Dead Code Your AI Assistant Left Behind AI assistants leave dead functions, unused imports, and abandoned abstractions everywhere. Here's how to find dead code with grep and IDE tools, delete it safely, and stop the AI from generating more.
- How to Simplify Overly Complex AI-Generated Functions (Without Breaking Them) AI assistants over-engineer everything — factory patterns for one implementation, abstract classes for nothing, 5 nested conditionals for a yes/no. Here's how to simplify AI-generated code to match the actual complexity of the problem.
- How to Make Your Codebase AI-Friendly: A Complete Guide Your AI assistant is only as good as the codebase it reads. Structure files for context windows, name things consistently, and write comments the AI actually uses. Complete practical guide for making any codebase AI-friendly.
- How to Structure Files So AI Agents Don't Break Your Architecture AI agents generate code in the wrong files, break module boundaries, and turn your project into a monolith. Here's how to structure directories and files so AI agents generate code that fits your architecture.
- How to Name Things So AI Assistants Generate Better Code AI assistants pattern-match on your existing names. Inconsistent naming produces inconsistent AI-generated code. Here's the naming system — descriptive, searchable, consistent — that makes AI assistants generate code that fits your project.
- How to Write Comments That AI Assistants Actually Read and Use AI assistants read your comments to understand intent and constraints. But they ignore noise and copy bad patterns. Here's what to write — intent over mechanics, constraints over descriptions, and contracts over implementation.
- How to Debug AI-Generated Code: A Complete System for When You Don't Understand What the AI Wrote Your AI wrote 300 lines and you don't know what any of it does — and now it's broken. Here's a repeatable debugging system: isolate, bisect, instrument, explain. No prior understanding required.
- How to Debug an AI-Generated API That Returns Wrong Data Your AI built an API endpoint. It returns 200 OK with wrong data. Here's how to trace request → handler → response when you didn't write the handler — isolate the broken function, instrument it, and get a targeted fix.
- How to Debug AI-Generated Database Queries That Return Wrong Results Your AI wrote a database query. It runs, but returns the wrong data — missing rows, wrong counts, stale results. Here's how to extract the raw SQL, test it directly, and fix it without the AI rewriting your whole data layer.
- How to Find Which AI-Generated Change Broke Your App Using Git Bisect Your AI made 15 commits yesterday and now something's broken. git bisect pinpoints the exact commit in minutes without reading any code — just a yes/no test. Step-by-step for AI builders.
- Eventual Consistency vs Strong Consistency: What's the Difference (and When Does It Matter)? Strong consistency guarantees all readers see the same data immediately. Eventual consistency saves latency and availability but lets reads return stale data. Here's when each is the right call.
- How to Choose a Database for Your App: A Decision Guide Workload, consistency, data shape, scale, and ops burden — the five questions that decide which database you should use, with a comparison table and the cases where each option is wrong.
- How to Refactor AI-Generated Code Without Breaking Your App Your AI assistant wrote a 400-line function and you need to clean it up. Here's the step-by-step refactoring loop that keeps tests green — one small change at a time, with the diff you can actually review.
- What Are the Different Types of Databases (and What Is Each One For)? Relational, document, key-value, wide-column, graph, time-series, search, and vector databases — what each data model is, the use cases it fits, and the ones it breaks.
- How to Design a Database Schema (That You Won't Have to Rewrite) Design a schema from your queries, not your entities: primary keys, relationships, column types, constraints, indexes, and the migration order that survives deploy day.
- The 12 Database Mistakes That Show Up in AI-Generated Apps Missing indexes, N+1 queries, float money, naive timestamps, unpooled connections, and destructive migrations — the twelve database mistakes generated code ships with, and the fix for each.
- Why Does the AI's Code Keep Failing Linting (and How to Fix It)? Your AI assistant generates code that fails every lint rule. Here's why, which rules to enforce in CI, and how to auto-fix the AI's output before it merges.
- What Is a Memory Leak (and Why Does Your App Get Slower the Longer It Runs)? A memory leak is memory your app never releases. Learn why AI-generated code leaks it, how to find the cause, and how to fix it in Python and Node.js.
- Postgres vs MySQL: Which Should You Use? Postgres and MySQL are far closer than the folklore says. Compare them on types, JSON, constraints, and operations, and get a direct recommendation.
- SQLite vs Postgres: Which Should You Use? SQLite is fast and zero-ops but single-writer. Postgres is concurrent and multi-user. Compare them, and see why local SQLite plus prod Postgres breaks.
- What Is OpenAPI (and Do You Need It)? OpenAPI is a machine-readable description of your API. Learn what it is, what it is not, and whether a small app should bother with a spec.
- Offset vs Cursor Pagination: Which Should Your API Use? Offset pagination skips rows and drifts as data changes. Cursor pagination seeks directly and stays consistent. Compare them and learn when each is right.
- Why Does My App Work Locally but Not in Production? It works locally because your machine supplies what production lacks: env vars, a real database, permissive CORS. A checklist of every divergence.
- How to Test AI-Generated Code (Before It Reaches Production) AI-generated code needs a higher testing bar, not a lower one. Learn how to write tests you can trust, find the gaps, and verify before merge.
- What Is an API Gateway (and When Do You Need One)? An API gateway is a single entry point that routes, authenticates, and rate-limits all your API traffic. Learn what it does and when it's overkill.
- What Is a Database Transaction (ACID)? A transaction groups database operations so they all succeed or all roll back. Learn ACID, why transfers need it, and how to use it in code.
- What Are Database Migrations (and Why Do They Break Deploys)? A migration is a versioned change to your database schema, applied in order. Learn how they work and the failure modes that take down deploys.
- What Is an ORM (and When Should You Use Raw SQL)? An ORM maps database tables to objects so you write queries in your language. Learn what it hides, what it costs, and when raw SQL is the right call.
- What Is Eventual Consistency (and Why Do My Reads Return Stale Data)? Eventual consistency means a write becomes visible everywhere after a delay. Learn why distributed systems use it and when stale reads are a problem.
- What Is Memoization (and When Does It Actually Help)? Memoization caches a function's results by its arguments so repeat calls skip the work. Learn when it's a huge win and when it's wasted effort.
- What Is Linting (and Why Does the AI's Code Keep Failing It)? A linter checks code for bugs, style problems, and dangerous patterns before it runs. Learn how to set one up and why AI-generated code needs it.
- How to Debug AI-Generated Code When You Don't Understand It Debugging code you didn't write is a skill. Learn the method: read the error, reproduce minimally, bisect the change, and interrogate the code.
- What Is Refactoring (and How Do You Do It Without Breaking Everything)? Refactoring restructures code without changing behavior. Learn the rule that makes it safe and how to use AI for it without breaking your app.
- How to Write a README That People (and AI) Can Actually Use A good README tells a stranger how to run your project in two minutes. Learn the six sections that matter and what AI agents read in yours.
- What Is Version Control (and Why Do You Need It)? Version control records every change to your code so you can compare, revert, and collaborate. Learn the core concepts and the habits that matter.
- What Is AI Code Validation? AI code validation is the process of verifying that code generated by an AI assistant is correct, secure, and fit for production. Learn what to check and how.
- What Is a Git Merge Conflict? A merge conflict happens when two branches change the same part of a file. Learn what causes them, how to read the markers, and how to resolve them.
- What Is Continuous Delivery? Continuous delivery means every code change is automatically built, tested, and kept ready to deploy at any moment. Learn how it differs from CI and continuous deployment.
- What Is a Database Deadlock (and How Do You Fix It)? A deadlock is two transactions each holding a lock the other needs. The database detects it and kills one. Here is why generated code creates them and how to make them stop.
- How to Read an EXPLAIN Plan A step-by-step reading of a query plan: what each node does, which numbers matter, and how to spot the scan or the estimate that explains a slow query.
- What Is a Composite Index? A composite index covers several columns in a defined order. Which queries it can serve depends on the leftmost columns, which is why column order is the whole design decision.
- What Is a Covering Index? An index that contains every column a query needs can answer it without visiting the table at all — an index-only scan, which is faster and cheaper than any ordinary index.
- Cache Invalidation Explained Stale data is the price of caching. Here are the strategies that keep it bounded — TTL, write-through, purge on write, versioned keys — and how to choose between them.
- What Is a Cache Stampede? When a popular key expires, every request for it can miss at once and hit the database together. Here is how to detect and prevent the thundering herd.
- What Is a Distributed Lock? A distributed lock gives one process exclusive access to a resource across machines. It is easy to implement badly and hard to get right, so here is what it guarantees and where it fails.
- What Is the Outbox Pattern? Writing to the database and sending a message are two operations that cannot both be atomic. The outbox pattern makes the message a database row first, then delivers it reliably.
- What Is a Saga Pattern (and How Is It Different From Two-Phase Commit)? Sagas coordinate a multi-service operation through local transactions and compensating actions; two-phase commit uses a coordinator that blocks. Which one fits depends on consistency needs.
- How to Version an API A practical versioning process: choose a scheme, make additive changes without breaking clients, deprecate on a schedule, and prove the contract with tests.
- What Is a Materialized View? A materialized view stores the result of a query as a table. It makes expensive reads fast at the cost of staleness and maintenance — and it is not the same as a view.
- How to Handle Timezones in a Database Store instants in UTC, store the user's zone separately, and convert at the edges. A step-by-step pass over the decisions that prevent silent time bugs.
- What Is Sharding? Sharding splits one large dataset across several databases so no single machine has to hold it all. It is a last resort, and the shard key is the decision you live with.
- What Is a Read Replica? A read replica is a copy of your database that follows the primary. It scales reads, and it introduces replication lag — which is a correctness problem, not just a delay.
- What Is AGENTS.md (and Why Does Your Agent Ignore Your Rules)? AGENTS.md is a plain markdown file at the repository root that tells an AI coding agent how your project works. Here is what belongs in it and why rules are often skipped.
- How to Set Up MCP Servers for a Coding Agent A step-by-step setup of Model Context Protocol servers: choosing transports, wiring configuration, passing secrets as environment variables, and verifying the tools appear.
- How to Sandbox an AI Coding Agent Run a coding agent with limited filesystem access, no ambient credentials, and restricted network egress — without making the workflow unusable.
- What AI Coding Actually Costs Per Month Subscription seats, metered tokens, and the hidden costs of context and retries — a way to model what AI-assisted development costs a solo builder or a team.
- How to Manage an AI Agent's Context Window Context is the agent's working memory: finite, resent every turn, and the main reason long sessions degrade. How to keep the right things in it.
- How to Stop Two AI Agents Editing the Same File Concurrent agents overwrite each other's work unless you partition the filesystem. Worktrees, file ownership, and a merge order that keeps both diffs intact.
- What Is a Decision Model? Jev, Laya, and Typed Answers Instead of Parsed Prose A decision model returns a typed choice, score, or yes/no probability instead of generated text. How Jev, Laya, and Clef work, and when to use one.
- What Is Jev? TypeSafe's Decision-Only Model Explained Jev takes a state and typed questions and returns choices, scores, and yes/no probabilities. What it is good at, what it is not, and how it is priced.
- How to Set Up Jev in Your App (API Key, SDK, and First Decision) A step-by-step Jev setup: create a key, install the SDK, send typed questions, read confidence, and add a fallback before it touches users.
- What Is Laya? The Open-Source Jev Alternative You Can Run Locally Laya is an Apache-2.0 decision engine you run on your own hardware. What its checkpoints do, how the router works, and where it trails hosted models.
- How to Run Laya Locally: Install, First Decision, CLI, HTTP, and MCP Install Laya, run a first typed decision, use the CLI and presets, serve it over HTTP, and connect it to a coding agent over MCP.
- Jev vs Laya vs Clef: Which Decision Model Should You Use? A practical comparison of Jev, Laya, Clef, and OpenAI's Decisions API: hosting, license, modality, price, latency, and when each one wins.
- How to Add a Decision Model to a Vibecoded App A practical integration pattern: choose one branch, write atomic questions, gate on confidence, keep actions in code, and roll out in shadow mode.
- How to Evaluate a Decision Model Before You Ship It Build a labeled set, measure accuracy and calibration, choose a confidence threshold, and run shadow mode before a decision model takes action.
- Jev AI: The Complete Guide to TypeSafe's Decision Model Jev AI explained: what it is, what it returns, pricing, latency, use cases, setup, limitations, and how it compares with Laya, Clef, and OpenAI.
- Laya AI: The Complete Guide to the Open-Source Decision Model Laya AI explained: checkpoints, router, local setup, speed, cost, fine-tuning, security, and how it compares with Jev and other decision models.
- Jev Use Cases: 15 Decisions Worth Replacing an LLM Call For Fifteen practical Jev use cases, grouped by workflow, with the question shape and the reason a typed decision beats an LLM call.
- Jev Pricing: What a Decision Actually Costs Jev costs $0.042 per million input tokens with free output. Here is the arithmetic per decision, what makes it expensive, and how it compares with alternatives.
- How to Use Jev as an LLM Guardrail Screen LLM inputs and outputs with Jev: define hazard questions, batch them into one call, map probabilities to pass, review, block, or support.
- How to Fine-Tune Laya on Your Own Decision Data A practical Laya fine-tuning loop: prepare CSV or JSONL, dry-run the job, train, calibrate confidence, evaluate, and serve the checkpoint.
- How to Connect Laya to a Coding Agent Over MCP Install Laya's MCP server, configure a coding agent, verify the tools, and use typed decisions for routing, triage, and guardrails.
- Laya Security: Pin Checkpoints, Verify Digests, and Protect laya-serve Secure a local Laya deployment: pin checkpoint revisions, verify SHA-256 digests, authenticate laya-serve, and treat model answers as recommendations.
- Can Prompt Injection Manipulate a Decision Model? Decision models return typed labels, not text, but their state is untrusted input. How injection can steer a choice and how to defend the layer.
- How to Write Decision Questions for Jev and Laya A practical guide to choice, score, and noul questions: instructions, criteria, atomicity, thresholds, and the tests that catch ambiguous labels.
- Jev Images and Box Questions: What the Preview Can Do How to send images to Jev, enable the danger-zone header, use Box questions for image localization, and decide when a preview is not production-ready.
- Jev vs an LLM Classifier: Cost, Latency, and When to Switch A practical comparison of a decision model and an LLM classifier: contract, latency, token math, accuracy, calibration, and the hybrid pattern that works.
- Spec-Driven Development vs TDD: Which Comes First? TDD drives design with failing unit tests; spec-driven development fixes behaviour and contracts first. They operate at different altitudes.
- Spec-Driven Development Tools Compared Spec tooling falls into plain markdown, structured toolkits, IDE-native workflows, and registries. They trade flexibility for enforcement.
- Spec-Driven Development: A Worked Example A complete spec for one endpoint: goal, contract, rules, acceptance criteria, and non-goals. The same structure scales to a migration.
- How to Write Acceptance Criteria an AI Agent Can Verify An agent satisfies the literal text it is given. Criteria must describe observable behaviour, include boundaries, and avoid adjectives.
- What Is a Design Doc (and Do You Need One)? A design doc records the problem, options, decision, and trade-offs. It is where architecture reasoning survives after the chat window closes.
- What Is Prompt Caching (and How Much Does It Save)? Prompt caching reuses the model's processed prefix, charging less for repeated input. It only works when the stable part comes first.
- What Is Model Routing (and When Should You Downgrade)? Model routing sends each request to the cheapest model that can handle it, with a fallback. It needs per-route evaluation, not a hunch.
- How to Set a Token Budget Per Task A token budget caps input, output, and retries per task. Set it from measured usage, not the model's maximum context window.
- How to Measure Token ROI Token ROI is the value of a completed task divided by its full token cost, including retries, failures, and human review time.
- LLM Observability: What to Log and Trace Trace prompt version, model, tokens, tools, latency, cost, and outcome per request, with sensitive content redacted before storage.
- What Is an AI Gateway? An AI gateway centralises provider keys, routing, limits, caching, logging, and fallback. It also concentrates secrets and prompts in one place.
- How to Productionize an AI App Productionizing an AI feature means adding quotas, timeouts, fallbacks, evaluations, cost controls, and observability around a demo.
- How to Connect an AI App to Production Data Securely Do not hand the model a database credential. Put a scoped tool layer between model and data, with tenant filters and an audit trail.
- What Are Agent Skills (and What Is a SKILL.md File)? An Agent Skill is a folder containing a SKILL.md that tells an agent how to perform one job. The agent loads it only when the task matches.
- Agent Skills vs MCP vs AGENTS.md: What's the Difference? AGENTS.md sets standing rules, Agent Skills package one procedure, and MCP connects tools and data. They solve three different problems.
- What Is the Agentic AI Foundation (AAIF)? The Agentic AI Foundation is a Linux Foundation body that hosts vendor-neutral agent standards, including MCP, AGENTS.md, and Agent Skills.
- How to Write a SKILL.md File an Agent Actually Follows Write one narrow procedure per skill, put the trigger conditions in the description, and end every step with a check the agent can run.
- How to Audit an Agent Skill Before You Install It Read what the skill tells the agent to run: download-and-execute steps, broad file reads, permission changes, and hidden network calls.
- What Is Agentic Engineering (and How Is It Different From Vibe Coding)? Agentic engineering is directing agents inside an engineering process: specs, review, tests, and limits. Vibe coding skips the process.
- What Is Mid-Response Steering for a Coding Agent? Mid-response steering lets you correct an agent while it is still working, instead of cancelling the run and starting over.
- What Is Plan Mode in a Coding Agent? Plan mode makes the agent propose steps before it edits anything, so you can reject a wrong approach while it is still cheap to change.
- What Are Agent Mods (and Should You Use Them)? A mod is a packaged bundle of agent customisation: instructions, commands, and hooks installed as one unit. Convenience and risk arrive together.
- How to Hand a Task to Another Coding Agent A handoff needs a written state file: what changed, what was decided, what is open, and the exact command that continues the work.
- What Is Agent Memory (and Why Does Your Agent Forget)? Agent memory is whatever the harness carries across sessions: files, summaries, and retrieval. Context inside a session is not memory.
- How to Keep a Coding Agent On Task for Hours Long runs need a written plan, commit checkpoints, an explicit stop condition, and a budget. Without them the agent expands the task until it fails.
- How to Version and Pin Agent Skills Across a Team Treat skills like dependencies: commit them, pin them, review changes, and record which version each project uses.
- Why Is Code Review the Bottleneck in Agentic Coding? Agents produce code faster than teams can read it, so the constraint moves from writing to reviewing, and unreviewed code is not an asset.
- How to Review a 2,000-Line AI Pull Request Review in passes: intent and scope, then risky surfaces, then tests, then the diff. Do not read a large change top to bottom.
- What Is a Review Packet (and Why Agents Should Produce One)? A review packet is the evidence an agent hands over with a change: intent, decisions, risks, and how to verify it. It makes review possible at speed.
- How to Set a Pull Request Size Budget for AI Agents Give the agent a files-and-lines budget before it starts, enforce it in CI, and split by concern when it is exceeded.
- What Is Risk-Based Code Review? Risk-based review sends scrutiny where a mistake is expensive: authorization, data, money, and irreversible operations. Everything else gets lighter checks.
- How to Use an AI Code Reviewer Without Trusting It Run AI review as a filter for specific defect classes, verify every finding against the code, and keep the approve decision with a human.
- How to Stop an Agent From Gaming Its Own Tests Agents optimise for the signal you give them. Make the tests independent, review test changes as strictly as code, and verify by mutation.
- What Is Agent Drift (and How Do You Catch It)? Agent drift is a run slowly leaving the task: scope grows, conventions slip, and the plan stops matching the diff. It is caught at checkpoints, not at the end.
- Why Does My Agent Ignore AGENTS.md? Usually the file is not being read, is too long to matter, or states preferences instead of checkable rules. All three are fixable.
- Why Is My Coding Agent Stuck in a Loop? A loop means the agent has no way to tell whether its last attempt worked. Give it a check it can trust, or stop the run.
- Why Does My Agent Keep Editing the Wrong File? Duplicate files, generated copies, and generic names make several paths look equally plausible. Name the path in the task and remove the duplicates.
- Why Does My Agent Say the Tests Pass When They Fail? The agent is usually reporting a command it did not run, a subset it did run, or output it misread. Require the command and the raw result.
- Why Did My AI Coding Bill Spike? Usually a long agent run re-sending context, a large file read repeatedly, or a retry loop. Find the expensive action before changing plans.