AI agents · tools
-
What is beam search? How it differs from greedy decoding, and why chatbots use sampling more
Beam search keeps several candidates per step and picks by cumulative score, while greedy picks one token. This post covers why chatbots prefer sampling and when beam search fits.
-
How do you use Ollama? From installation to your first local LLM run and API call
Learning how to use Ollama on Linux starts with installing the binary, running the local server (ollama serve), registering a language model, and calling it from the CLI (ollama run) or the local REST API on 127.0.0.1:11434 with curl.
-
CNN vs LLM: why a small dedicated model beats a large language model at image classification
Understanding the difference between a CNN and an LLM clarifies when to use a dedicated classifier versus a general-purpose generative model for image classification. This post compares how a CNN and a multimodal LLM approach skin lesion classification in terms of architecture and training, reports a small dermatologist-run experiment, and outlines limits, FAQs, and when to combine both model types.
-
What is positional encoding? How Transformers know word order and how RoPE differs
Positional encoding is the mechanism that injects token position information into a Transformer so the model can tell word order apart. This post explains why Transformers need explicit order information, how sinusoidal positional encoding and learned positional embeddings work, and how Rotary Position Embedding (RoPE) differs by rotating Query and Key vectors.
-
Batch normalization vs layer normalization: why do transformers use LayerNorm?
Layer normalization and batch normalization stabilize deep network training by normalizing activations across layers. This post explains how they differ in which axis they aggregate mean and variance, how that affects mini-batch and inference behavior, and why transformers standardize on LayerNorm.
-
What is an optimizer? SGD vs momentum vs Adam, and which to pick first
An optimizer applies backpropagation gradients to update neural network weights. This post compares SGD, momentum, Adam, and AdamW, how they move on a loss surface, and common starting choices.
-
What is cross-entropy loss? Why classification models use it instead of MSE
Cross-entropy loss measures how much probability a classification model assigns to the true class. This post covers -log(p), the softmax pipeline, why it beats MSE for classification, and its role in LLM pretraining.
-
What is speculative decoding? Why a small draft model makes LLM answers faster
Speculative decoding proposes several next tokens with a small draft model and verifies them in one forward pass with the large target model. This post covers why total compute can rise while latency drops, when speedups shrink, and how output quality stays aligned with the large model.
-
What is a learning rate? How to adjust it when the loss jumps around or won't go down
The learning rate is the hyperparameter that sets how far weights move along the gradient in one gradient-descent step. This post covers update rules, loss behavior when the rate is too large or small, tuning with short experiments, and learning rate schedulers with warmup.
-
What is RLHF? Aligning LLM outputs with reward models, PPO, and DPO
RLHF trains a reward model on human comparison data, then tunes the language model with PPO reinforcement learning. This post covers reward model training, the KL penalty, reward hacking, and how DPO differs.
-
What is an activation function? ReLU vs GELU vs sigmoid, and how to choose
Activation functions add nonlinearity between linear layers so deep networks can learn patterns beyond a single straight decision boundary. This post covers why they are needed, how sigmoid, ReLU, and GELU differ in shape, their tie to vanishing gradients, and how to pick activations for hidden versus output layers.
-
What is formal verification? How it differs from testing and fuzzing, and what changes when an LLM writes the proofs
Formal verification states rules mathematically and uses a proof checker to confirm they hold across all inputs in scope—unlike tests or fuzzing—yet "verified" does not mean bug-free if the spec or machine model diverges from reality. This post covers what LLM-written proofs change, and how verification relates to Rocq, ASan, and C++26 Contracts.
-
What is knowledge distillation? Training a small model from a big one, and how it differs from quantization
Knowledge distillation trains a smaller student model to match the class probability distributions (soft targets) produced by a large teacher model. This post covers why soft targets beat hard labels alone, temperature, how distillation differs from quantization, and when to use it.
-
What does the post-task Q&A in an AI skills assessment check, and how do you prepare?
The post-task Q&A in an AI skills assessment asks you to explain your deliverable and decision rationale after submission, then cross-checks your answers against the actual implementation. It mainly probes cognition—whether you can explain how your result works and where it can fail. Recording the why as you work and practicing answers in weakness, risk, and next-verification order are among five habits that help you prepare.
-
What is backpropagation? How a neural network uses gradients to fix its weights
Backpropagation passes the loss from the output layer back toward the input, using the chain rule to compute each weight's gradient in a multi-layer network. This post covers the four-step training loop, what gradients mean, a chain-rule walkthrough, and how backpropagation differs from gradient descent.
-
What are the three debts of AI coding agents? Technical, intent and cognitive debt, and habits that reduce them
Delegating work to an AI coding agent produces code quickly, but alongside technical debt it can accumulate intent debt—where what is being built and why is never recorded—and cognitive debt, where the team loses understanding of the system. Habits such as pulling out requirements one by one, scoping each prompt, cross-checking numbered requirements against evidence, recording the why, and delegating in small chunks reduce these debts.
-
What is an LLM confidence score? Why you should not just ask the model how sure it is, and what calibration means
Developers often want an LLM confidence score when building support agents, but a number from simply asking the model how sure it is cannot be trusted at face value. This post explains why and what calibration means.
-
What are AI Native and AI literacy? The difference and how to build them
AI literacy is defined in public documents such as the EU AI Act as the ability to understand how AI works, judge its outputs critically, and use it responsibly. AI Native has no standard definition and commonly describes working or designing systems with AI as the default premise. This post explains the difference, competence stages, work examples, and how to build both, based on public sources.
-
What is latent reasoning? How it differs from CoT when an LLM thinks without writing text
Latent reasoning feeds the last-layer hidden state back as the next input instead of writing intermediate thoughts as tokens. CoT leaves readable text but costs more tokens; latent reasoning can use fewer tokens but is harder to audit. This post covers tool calling and inspectability based on the Hybrid Reasoning Agents paper.
-
What is overfitting? How to fix it when training loss falls but validation loss rises
Overfitting means the model fits the training data so closely that it fails on new data. When validation loss rises while training loss keeps falling, suspect overfitting. This post covers reading loss curves, diagnosis, and fixes in order: early stopping, more data, regularization, dropout, and smaller models.
-
What is an LLM inference framework? How serving engines like vLLM and llama.cpp differ when you choose one
An LLM inference framework is the runtime that loads trained weights, accepts requests, and produces tokens. This post compares server-style engines such as vLLM with local-style ones such as llama.cpp, how to choose, and why model makers ship their own engines.
-
What is Grok 4.8? What a 2.5T-parameter model and a C++ training stack mean
Official public information on Grok 4.8 comes down to Elon Musk's posts on X. This post explains a rough memory estimate for 2.5T parameters, what the RL stage generally means, and common reasons teams choose a C++ training stack.
-
What is the difference between an NPU and a GPU? A simple comparison by structure, use case, and power
The NPU vs GPU gap comes down to design focus: a GPU is a general-purpose parallel processor, while an NPU is a dedicated accelerator built around multiply-accumulate (MAC) ops for neural networks. This post compares structure, training vs inference, and power and use cases for beginners and embedded developers.
-
What is mechanistic interpretability? How it differs from polysemanticity, where one neuron holds many concepts
Mechanistic interpretability reverse-engineers a model's internal neurons, features, and circuits—unlike XAI attribution that only highlights which inputs mattered. This post explains polysemanticity, superposition, sparse autoencoders (SAEs), and the ongoing debate around whether neural networks are "clean."
-
AI basics and AI task-solving: a final review the day before
A same-day review: one-page concept summary, 10 O/X pitfalls, document-and-data AI task workflow, and a practice mistake checklist for a 30–40 minute morning pass.
-
SK hynix AI Hackathon first-round qualifier review (short)
Brief thoughts after the SK hynix AI Hackathon first-round qualifier—no problem spoilers. Multiple-choice section, AI-assisted tasks, and links to prep posts.
-
AI Basics Practice Quiz Part 2: 28 Multiple-Choice Questions — Can You Answer the Same Concepts From a Different Angle?
Part 2 of the AI basics practice quiz: 28 four-option questions in 10 groups that revisit the same concepts from new angles, with answers and explanations in toggles below each question.
-
AI Basics Summary and 28 Practice Questions: How Do You Tell Confusing Concepts Apart?
Based on this blog's AI study posts, this guide summarizes 15 topics with key ideas and easy-to-mix-up comparisons, plus 28 self-made multiple-choice questions with answers and explanations.
-
How I approach document- and data-based AI tasks (the one-turn prompt formula)
A practical playbook for LLM tasks over policy PDFs, master tables, and logs: verbatim questions, one-turn prompts, trimmed output, verification on a different path, and spot-checking boundary rows.
-
What is WSL? Why AI Agents Run More Reliably Inside WSL on Windows
WSL 2 runs a real Linux kernel in a lightweight VM on Windows. This post covers why agent tools expect Bash, POSIX paths, execute bits, and case sensitivity; where to keep project files; install commands; and fact-checking recent WSL 3.0 claims—on a WSL 2 basis.
-
How should you prepare for an AI exam? What I learned studying, plus an exam setup checklist
Preparing thoroughly for an online AI exam requires two essential pillars: a systematic study loop and an advance check of your online proctored exam setup. First, explain concepts in simple words, quiz yourself, write your own answer before reading the explanation, and then compare. When delegating tasks to AI, establish a solid 4-step routine: common material, conditions, verification, and format. Second, install the Monito app—accessed via your invited exam link—grant camera and microphone permissions, and prepare a phone stand, Do Not Disturb mode, and chargers. Third, never cheat under any circumstances, and always follow the official guidelines of the exam you are taking.
-
What Is Speech Recognition (STT)? How Speech Becomes Text, and How On-Device STT Differs
Speech-to-text (STT) converts speech into text by sampling continuous sound waves at 16,000 numbers per second (16 kHz), transforming them into a 2D mel spectrogram aligned with human hearing, and using a Transformer encoder-decoder to predict text tokens sequentially. While cloud STT offloads processing to remote servers, on-device STT runs optimized, smaller models locally on the device—eliminating network latency, enabling offline operation, and keeping voice data private, at the cost of tighter compute and model size constraints.
-
Prompt, Context, Harness, and Graph Engineering: What Is the Difference?
Prompt engineering is writing and organizing the instructions you give an LLM; context engineering is curating and managing everything the model sees, including tool definitions, retrieved data, history and memory beyond the instructions (Anthropic's definition). Harness engineering is designing the runtime around the model (tools, loops, verification, permissions, state), and graph engineering is structuring work as a graph of nodes, edges and shared state, LangGraph-style, to fix the flow. The last two are recent terms without a standard definition, so this post summarizes how they're actually used, with sources.
-
How a Solo Founder Organizes an AI Team and Builds a Product in Stages
The cases published by people building products alone with AI share a structure. The human sits at the top and keeps direction, product decisions, approval and customer relationships; below that, a coordinator agent splits the work and hands it to role agents (product, build, verification, marketing and support). Official docs from Anthropic, OpenAI and CrewAI all advise starting with one agent and adding roles and hierarchy only when needed. The solo-founder cases, however, are all self-reported, so independently verified evidence is still thin.
-
What Is an Embedding? How Turning Words into Vectors Lets Us Compare Meaning
An embedding turns data such as words into numeric vectors that carry meaning. Once words are vectors, you can calculate how similar their meanings are from distance or angle, and the standard way to compare by angle is cosine similarity.
-
Day5–7: AI Limitations, Embedding and RAG Architecture, AI Agents and Tool Calling
Hallucination happens because an LLM predicts the plausible next token by probability instead of looking up facts. RAG is the whole method of finding relevant documents and putting them into Context, and an Agent is the loop where the LLM picks a tool, looks at the result, and decides the next action itself.
-
What Is MoE (Mixture of Experts)? How It Differs from Dense Models and Why It Needs So Much Memory
MoE keeps several expert FFNs instead of one, and a router runs only a few of them (top-k) for each token. Per-token compute stays small, but every expert still has to sit in memory, so the memory footprint is large.
-
Programmers AI Assessment Practice Review: Why Do I Get Stuck Using AI the Way I Code?
I tried the Programmers AI Assessment practice set and got a little over half right. I'd thought it would be easy, and it hit me that at this rate I'd fail. The problem was asking AI from the start, the way I do when coding. Now I'm preparing with one rule: "AI is the hands; I'm the head."
-
What Are Tokens and Context Windows? How LLMs Count Text and Why Length Limits Exist
An LLM token is the basic unit a model uses to process text, and the context window is the cap on how many tokens one request can hold. Counts depend on the encoding and language, and hidden reasoning tokens take space inside that limit too.
-
Pretraining vs Fine-Tuning vs RLHF: What Stages Build an LLM?
Pretraining, fine-tuning, and RLHF are the stages that typically build an LLM. Pretraining uses next-token prediction to make a Base model, supervised fine-tuning uses instruction–response examples to make an instruction-following model, and RLHF folds in human preferences to make a conversational model.
-
What Is the SK hynix AI Hackathon 2026? Passing the Document Round and My Resolve for Round 1
The SK hynix AI Hackathon 2026 is an individual contest where you prove your AI skills with results, regardless of education, major or years of experience. I passed the document round with a portfolio about making embedded verification unattended together with AI agents, and I'm now preparing for Round 1 in October.
-
What Are Temperature and Top-p? Why LLM Answers Change Every Time
Temperature and top-p control how an LLM picks the next token. Temperature shapes the probability distribution, while top-p and top-k set the candidate range, so the same question can get a different answer when sampling is used.
-
What Is Quantization? FP16 vs INT8 vs INT4 and Why LLM Memory Shrinks
LLM quantization stores weights with fewer bits, which cuts memory use and how much data has to be read. This note compares FP16, INT8, and INT4, and why that saving matters when Decode is memory-bound.
-
When Does the Cost Burden Flip from an API Plan to a Local AI Box?
An API subscription is enough when repeated work stays at human pace, the data may leave the building, and a limit only means wait or switch model. A local box is the candidate when residency, round-trip latency, or the same quota keeps stopping the job. Cut retries and oversized context before you add hardware.
-
Agent Browser Automation: Only After MCP Fails? Branch Criteria
Connector-first MCP vs browser fallback: why MCP first, signals to switch to the browser, and login/2FA as human handoff only. No pricing or invented UI paths.
-
When Should You Switch Between Claude Sonnet 5.5 and Opus 5.5 for Coding?
Everyday coding stays on Sonnet 5.5; open-ended judgment and long runs stay on Opus 5.5. The migration note is thinking and between_tools. Prices and benchmark figures are left out.
-
GitHub Copilot Chat vs Cursor Agent: How to Split Roles
How to split Copilot Chat (inline / IDE assist) and Cursor Agent (multi-file agent loops) in one repo. No pricing, review scores, or invented UI.
-
AI Agent Context Budget: What to Summarize in Long Sessions
Minimum per-turn state, where progress notes and checklists live, and a restart prompt example. No pricing, token, or context-window numbers.
-
AI Agent Secret Hygiene: Never Put Keys in Rules
Keep credentials out of Cursor rules and AGENTS.md. Where .env, keychain, Cloud Secrets, and allowlists live, plus a leak checklist. No real keys or pricing.
-
Slack MCP Agents: Split Read-Only from Send
Start Slack MCP read-only, gate sends behind confirmation UX, and why channel invites matter. No pricing, tokens, or invented Slack click-paths.
-
AI Agent TDD Loop: Fix the Failing Test First
Lock an AI agent TDD loop to red→green→refactor: how to feed failing logs, one-cycle done criteria, and stop rules for infinite fix loops. No pricing.
-
Cursor Cloud Agent vs Local Agent: When to Use Which
How to split Cursor Cloud Agent and the local chat Agent: Cloud for PR/long jobs, local for interactive edits, plus handoff. No pricing.
-
How to Turn a Linear Issue into a Cursor Agent PR
What to copy from a Linear issue into a Cursor agent, a PR description template, and when to request review. No pricing.
-
Have Agents Reproduce Only Non-Flake Failures
Howto to filter retryable flake signals and prompt agents to reproduce and report only deterministic failures. Filter heuristics, minimal repro commands, report evidence. Fowler quarantine and CI-log process. No affiliates.
-
CLAUDE.md vs AGENTS.md: How Cursor Reads Them
How Cursor reads CLAUDE.md and AGENTS.md, always-apply vs conditional .mdc rules, and where mixed teams should put each file—per official Rules docs. No pricing.
-
Cursor .cursor/agents vs Rules — How Do You Split Responsibilities?
Howto for Cursor .cursor/agents vs rules boundaries: what belongs in agents, what belongs in rules, what breaks when they overlap. Grounded in official Agents/Rules docs. No affiliates.
-
Cursor Hooks: What You Can Run Before and After the Agent
Cursor hooks how-to for the agent lifecycle—before/after events, hooks.json, and /create-hook—from official Hooks docs. Not a retell of the save/commit guard post.
-
Cursor Skills vs Rules: When to Use Which
Decide Cursor Skills vs Rules from official docs: alwaysApply and globs triggers, and what /migrate-to-skills moves (and leaves alone). No pricing.
-
OpenAI Pro $200 is reopening — why does the limit look like half?
OpenAI Pro $200 subscriptions reopen on 2026-09-30. Here is why the new usage accounting can look like half the old allowance in API dollars, how the claim that you still get more done holds up, and what happens to the 5-hour cap and the previewed perks.
-
How to Have an Agent Implement from an ADR Alone?
Agent ADR implementation: required sections (MADR), limiting code scope, verification steps. Howto for ADR-only delegation. No pricing or affiliates.
-
Clean the Git Worktree Before Handing Off to an Agent
Checklist to clean or isolate a dirty git worktree before agent handoff: why clean first, how to mark remaining dirty. Grounded in git-worktree(1). No affiliates.
-
Enforce a Git Status Gate After Agent Work
Agent git status check: where to place it, whether to stop on a dirty tree, and intentional untracked allowlists. Grounded in git status --porcelain and hooks/commands. No pricing or affiliates.
-
A week with ChatGPT Sol and Luna at work — what actually felt different
A hands-on review of a week spent alternating between the options labeled Sol and Luna in the ChatGPT model picker. Where Sol earned its wait on heavy reasoning, where Luna was simply enough for daily drafting, and what disappointed — no benchmarks, just how it felt.
-
Claude Code /compact — What Do You Keep When Context Shrinks?
Before Claude Code compact: minimum state, restart prompts, and what belongs in files. Grounded in /compact, /context, and CLAUDE.md re-injection. No pricing or affiliates.
-
What Claude Code Router is and how to use it
Claude Code Router (CCR) is a local router that sends Claude Code and similar coding-agent requests to the providers and models you choose. This guide covers when you need it, how the config is structured, how to pick models and verify the route, and the most common mistakes.
-
Cursor Custom Subagents — Where Do You Define Them?
Howto for Cursor custom subagents: file locations, when to delegate, what stays in the parent prompt. Grounded in official Subagents docs. No pricing or affiliates.
-
Calling Cursor-like agents from Grok Bot to get work done
Grok Bot does not have to do all coding inside chat. It can delegate repo edits and PR creation to Cursor-style cloud or local agents. What delegation means, good task shapes, limits, and a practical blog/dev ops workflow.
-
What to configure first when running a local coding agent with herdr
Before any orchestration, a local herdr setup needs a work root, a clear place for model settings, permissions and deny paths, and a way to hand tasks to agents. A first-settings checklist and common first-week mistakes, based on the official herdr docs as of 2026-09-27.
-
Prompting Agents for Git Rebase Conflicts
How to safely hand only rebase conflict hunks to an agent: pass conflict files, success criteria, when humans must resolve. Grounded in git rebase docs. No pricing or affiliates.
-
What Is Claude Opus 5.5 — How Does It Differ from Opus 5 for Agent Coding?
Claude Opus 5.5 (model id claude-opus-5-5, shipped 2026-09-22) is the upgrade question for people whose coding-agent daily driver is still Opus 5.
-
Cursor @Folder Scope — When to Attach a Directory
Howto for choosing file vs folder with Cursor @-mentions: too-wide symptoms, monorepo minimum scope. Grounded in official @ mentions docs. No pricing or affiliates.
-
What Is GPT-6 Astra — Computer-Use Agents and the Critical Cyber Tier
GPT-6 Astra is the frontier computer-use model you choose when you are ready to hand an agent the OS, browser, and long-running work—not merely a smarter chat model.
-
MCP Elicitation: When Should an Agent Ask the User Back?
Tool failure vs MCP elicitation, minimal question schema design, and accept/decline/cancel/timeout handling. Grounded in elicitation/create. No pricing or affiliates.
-
How to Save Agent stdout to a Log File
Howto for reproducible agent stdout/stderr logs: where to redirect, keep failures only, read them next session. Grounded in shell redirect and tee. No pricing or affiliates.
-
How .cursorignore Shrinks What Cursor Indexes
Use .cursorignore to keep large artifacts, secrets, and build output out of Cursor indexing and agent context. Covers .gitignore differences, build patterns, and symptoms when the agent cannot read a file—no pricing or anecdotes.
-
Multi-Agent PRs: Branch Rules That Keep Reviews Sane
Split one branch per agent, keep humans as the merge gate, and cut conflicts with path ownership and frequent rebases. Practical multi-agent PR workflow—no pricing or personal anecdotes.
-
Why Run ripgrep Before Agent Codebase Search
How to narrow scope with rg before handing a whole repo to an agent. ripgrep glob/type vs agent codebase search, and how to paste hits into prompts. No pricing or affiliates.
-
Agent Output Eval Checklist
Pre-merge eval of agent output: feature/regression, security/secrets, docs/commit messages. Separate axis from agent-diff-review (read order). No pricing or affiliates.
-
Issue→Branch Naming Rules — Prefix, Issue Number, Collisions
Rules so agents name branches from issues consistently: prefix, issue number, collision handling. Common git/GitHub branch practice. No pricing or affiliates.
-
MCP Tool Schemas: Helping Agents Call Them Correctly
How to write MCP tool descriptions, required fields, and failure messages so agents misuse tools less. Schema design howto—not connection troubleshooting.
-
Resume an OpenCode Session After You Stop
Find session IDs, resume with --continue/--session, compact with /compact, and fork with --fork—grounded in official OpenCode CLI and TUI docs.
-
Giving Agents the API Spec Only (OpenAPI)
Pass agents OpenAPI only to cut invented endpoints and hallucinations: where to put the spec, how to supply response examples, how to reduce hallucinations. OpenAPI 3.1 practice. No pricing or affiliates.
-
Long-Job Checkpoints: How to Resume After an Interrupt
Where to save agent checkpoint files, resume prompts, and context-loss recovery. Separate axis from context-budget and opencode session resume. No pricing.
-
Agent Deny Path Lists — Secrets, Vendor, Bypass Detection
How to put secrets/vendor deny paths on agents: .gitignore, .cursorignore, and detecting bypass. Public ignore practice. No pricing or affiliates.
-
Reviewing Agent Diffs Like a Human
Human review checklist for agent-written diffs—what to check first, merge without tests?, rollback criteria. Separate axis from multi-agent-pr (branches/gates). No pricing.
-
Make Agents Split Commits by Patch
Rules so agents split large changes into patch-sized commits: one-commit criteria, message format, separating mixed changes. Grounded in git add -p and atomic-commit practice. No pricing or affiliates.
-
Codex CLI vs Claude Code: How to Split Terminal Agent Roles
Codex centers on AGENTS.md and config.toml sandboxing; Claude Code on CLAUDE.md, permissions, hooks, and subagents. Split by branch/worktree and form a triangle with the IDE agent.
-
Cursor Notepads: How to Use Them for Agent Context
Notepads were removed in Cursor 2.0. Move reusable context into Rules, Skills, Memories, or repo Markdown. Covers Notepad vs rules, when to create, and team sharing.
-
Injecting a Repo Map into the Agent
Which files belong in an agent repo map, how to auto-generate drafts, and how to retire stale maps. Separate axis from prompt-layers and Instant Grep. No pricing.
-
Have the Agent Write the PR Body
Agent PR body: template sections, diff-based summary, reviewer checklist. Separate from multi-agent-pr (branches) and linear-to-agent-pr (issue handoff). No pricing or affiliates.
-
Minimal AGENTS.md Template: What to Write in the Repo First
Start with overview, setup/test commands, code style, and security only. Share exact commands with CLAUDE.md; split long guidance into nested AGENTS.md files.
-
Claude Code Permissions and Network Allowlists: How to Narrow Them per Project
Put shared allow/deny rules in .claude/settings.json. Evaluate deny→ask→allow; gate the network with WebFetch(domain:) plus sandbox domains. Cursor rules describe intent; permissions enforce it.
-
CLI Quota Exhausted: How Do You Order the Fallback?
AI CLI quota fallback—symptoms, model-switch criteria, how to cut work cleanly. Spending / usage UI only. No price numbers or invented reviews.
-
A Flake-Only Retry Loop for Agents
Flake test agents: retry limits, isolation, and when to file an issue. Separate axis from agent-test-gate (pass/fail barrier) and agent-tdd-loop (write red→green). No pricing or affiliates.
-
Picking the Agent Root in a Monorepo
Monorepo agent root: choose cwd, package scope, and wrong-root symptoms. Separate axis from repo-map-inject (map injection). No pricing or affiliates.
-
How to Split System, User, and Project Prompts
Agent prompt layers—what goes where, conflict precedence, and when to split long rules. No Skills/Rules retell, no commands how-to, no pricing.
-
What Brief Do You Give When Delegating to a Subagent?
Subagent delegation brief—success criteria, context to include, how to receive results. Separate axis from context-budget (session progress). Grounded in Cursor Subagents docs. No pricing.
-
Put a Test Gate on Agent Output
Agent test gate: where to check, whether to stop on fail, and how it overlaps with CI. Separate axis from agent-tdd-loop (write loop) and agent-eval-checklist (merge eval). No pricing or affiliates.
-
Using AI on Excel and Spreadsheets
Lock cleanup and classification first, take formulas and pivots as drafts, then verify with totals, row counts, and samples. Paid sheet-AI prices are omitted.
-
AI Workflows for Google Drive and Docs
In Drive and Docs, take summaries and drafts as jobs, lock folder rules, and keep sharing permissions as a human gate. Paid add-on prices are omitted.
-
Using AI for Meeting Notes and Email
Lock meeting-note structure (decisions, open items, actions), split email drafts by purpose and banned phrases, then a person checks tone and facts.
-
Checklist for Search-Only Users — What to Learn Next
A checklist for leaving search-only habits, what to learn next, and how to pick an agent — without prices or rankings.
-
Delegating File Cleanup and Repetitive Work to Agents
Delegate only closed-rule repetition, choose local vs cloud by permission and backup, and prevent mistakes with dry-runs, samples, and rollback.
-
Cursor Composer vs Agent: When to Switch
Composer is Cursor’s agentic model; Agent is the tool-using mode. When to pick Composer, when to run Agent, and mid-task switch criteria. No pricing.
-
Cursor Background Agent vs Local: When to Use Which
Cursor Background Agent workflow: when to go background, vs local, and how to review. Separate axis from weekly cursor-cloud-vs-local-agent (Cloud/PR VM). No pricing or affiliates.
-
Turn Frequent Prompts into `.cursor/commands`?
Where Cursor custom slash-command files live, how trailing args work, and how they differ from rules. No Skills retell, no pricing.
-
Cursor Hooks: How to Guard the Agent Before Saves and Commits
Put project hooks in .cursor/hooks.json and user hooks in ~/.cursor/hooks.json. Use afterFileEdit for formatters and beforeShellExecution for shell gates; block with deny, exit 2, or failClosed.
-
Git Worktree for Agent Isolation
How to isolate agents with linked git worktrees: create, branch rules, pre-merge checks. Different axis from multi-agent-pr-workflow (PR/review). No pricing.
-
When an Agent Status Freezes in a Herdr Pane, Where Do You Look?
If a sidebar status looks stuck, run herdr agent explain, separate client detach from server restarts, then inspect output with agent/pane read.
-
MCP Auth Fail: What to Do on needsAuth
If the server shows needsAuth and tools are empty, that is auth—not a missing mcp.json. Symptoms, reconnect order, empty tool list. No pricing or token values.
-
MCP Resource vs Tool: When to Use Which
MCP resource vs tool selection: when resource, when tool, when both. Separate from mcp-tool-schema (schema design) and mcp-auth-fail (needsAuth). No pricing or affiliates.
-
Attaching a Local Coding Agent with OpenClaw: The Minimum Setup
Keep OpenClaw config under ~/.openclaw and run the Gateway, point local models at Ollama’s native endpoint, and opt in to the coding-agent skill with Claude Code, Codex, or OpenCode.
-
How to Use Agents in Real Work: An Overview
Search gathers answers; agents execute work. Split what you delegate from the checkpoints a person still owns.
-
Using AI Agents for PPT and Slides
Lock the outline first, split speaker copy from slide bullets, and keep design, figures, and brand as human gates. Paid PPT-tool prices are omitted.
-
Parallel Agents with Orca Worktrees
Create one git worktree per task with orca worktree create, pick the first-terminal agent with --agent, and treat isolation—not extra chats—as the parallel unit.
-
What is Orca CLI? Install and Run the First Commands
Orca CLI is the orca command that scripts a running desktop ADE. After the official install, verify with command -v orca and orca status --json.
-
From Search-Only ChatGPT to Agent Instructions
Turn a search sentence into a job with a goal, a scope, and a done-check. On failure, narrow the same goal instead of widening permission.
-
Cursor MCP Connection Failures: What to Check When a Server Does Not Appear
When a Cursor MCP connection fails, first check MCP Logs in the Output panel (Cmd+Shift+U on Mac, Ctrl+Shift+U on Windows/Linux). Then verify the mcp.json path and environment vari
-
Claude Code Project Settings: Locking Down Rules and Tool Permissions
To lock down Claude Code settings per project, put permissions allow/ask/deny rules in a committed .claude/settings.json plus a personal .claude/settings.local.json. Verify what actually applies with /permissions and /status.
-
When to Switch Between Cursor Agent, Ask, and Plan Modes
Cursor Agent mode handles actual code editing, Ask mode specializes in codebase analysis and Q&A, and Plan mode strategizes multi-file changes. This article covers when to use each mode and what breaks when the wrong one is chosen.
-
Configuring MCP Servers in Cursor with mcp.json
To connect an MCP server in Cursor, configure it in an mcp.json file. This article covers file locations, writing server entries, and troubleshooting connection failures.
-
AGENTS.md vs CLAUDE.md: Aligning Multi-Agent Rules in One Repo
Running more than one AI coding assistant against the same repository raises a question: how should AGENTS.md and CLAUDE.md relate to each other? This note covers role differences, sync strategies, and conflict resolution based on current official documentation.
-
Setting Up a herdr Workspace to Run Multiple Agents Side by Side
A herdr workspace groups the tabs and panes for one project or task, letting you run several agents side by side in one place. This overview covers workspace creation, tab and pane layout, and official best practices.