AI coding tools
Claude Code, Cursor, Copilot, OpenClaw and rivals: terminal agents, AI editors, app builders and self-hosted assistants, each with its own files and approvals. Interviewers ask how you steer yours.
on this pageshowhide
guide
overview
~1 minInterviews about AI coding tools are rarely about which button to press. They ask how you steer an agent that can read your repository, edit files and run commands: what you tell it before it starts, what you let it do without asking, how you check what it produced, and how you get back when it goes wrong. Teams adopting these tools want engineers who treat them as capable but fallible collaborators with a permission model, so the questions move quickly from features to judgement about context, risk and review. The hub is organised by product, and the products fall into three families. Terminal agents run in your shell and work through tools: [Claude Code](/topics/ai-claude-code), by far the largest section here, alongside [Codex](/topics/ai-codex) and [Gemini CLI](/topics/ai-gemini-cli). AI editors put an agent next to completions inside the IDE: [Cursor](/topics/ai-cursor), [Copilot](/topics/ai-copilot), which also reaches into github.com and the terminal, and [Windsurf, now Devin Desktop](/topics/ai-windsurf). Prompt-to-app builders generate, preview and host a whole web application: [Lovable](/topics/ai-lovable) and [v0](/topics/ai-v0). Learn one tool in depth before comparing them. The Claude Code sections touch nearly every idea the others share (instruction files, permission modes, checkpoints, hooks, headless runs, MCP servers, subagents), so its agent loop and its memory and context sections are the natural start. Then read the editor sections to meet the same ideas under other names, and the app builders last, where questions turn to who owns the generated code, what the built-in checks miss and what gates a release. Questions run from a junior choosing between two commands to a principal standardising one tool across a team. Names and flags change within months; the reasoning changes slowly, so learn the reasoning and date the details.
primer
A few ideas hold across every product in this hub. With them in place, most questions read as the same problem in a different tool. - **An agent is a loop around tools.** The model gathers context, proposes an action, the harness carries it out, and the result feeds the next step until the task looks done. Most questions about a tool are really about one stage of that loop: what it can see, what it is allowed to run, or how it decides it has finished. - **Instructions are context, not enforcement.** `CLAUDE.md`, `AGENTS.md`, Copilot instruction files, Cursor rules and `GEMINI.md` are text the tool adds to the prompt. The model usually follows them and sometimes does not. Anything that has to hold every time needs a mechanism the harness itself applies: a permission rule, a hook, a sandbox, a branch protection, a CI check. - **Two dials, not one.** One setting decides what the agent can technically reach (files, network, the machine outside the workspace); another decides when it stops and asks you. Some tools expose them separately, others fold both into a single mode. Knowing which dial a setting turns is most of what interviewers check when they ask about modes. - **Context is a budget.** The window fills with files, tool output and conversation, and quality drops as it fills with material the current task no longer needs. Layered instruction files, rules that load only for matching paths, clearing between unrelated tasks, summarising a long session and handing exploration to a subagent are all ways of spending that budget deliberately. - **Every change needs a way back and a check.** Checkpoints and rewind undo an agent's edits quickly, but version control is the record you share. Tests are evidence only if the agent did not weaken them to get a green run, so the diff still needs a human read. - **Nobody watching changes the defaults.** Headless runs, CI jobs and cloud agents cannot ask for approval, so they tend to start conservative. Widening what they may do is a decision about the runner, its credentials and its network, not about the prompt. - **Generated code is still your code.** App builders get to a working prototype fast. Ownership of the repository, where secrets live, who can read the data and what must be reviewed before a publish remain the engineer's job.
- Agent loop
- The cycle in which a model gathers context, chooses a tool call, receives the result and repeats until it judges the task complete or a person stops it.
- Harness
- The program around the model that offers it tools, executes the calls it requests, applies permissions and keeps the session; the part you configure.
- Instruction file
- A committed Markdown file such as CLAUDE.md, AGENTS.md or GEMINI.md that a tool loads into its context so every session starts with the project's conventions.
- Scoped rule
- An instruction attached only when its condition matches, typically a file glob or the agent's own judgement of relevance, so it costs context only where it applies.
- Permission mode
- A named preset deciding which actions an agent performs without asking, from read-only planning through approving edits to approving everything.
- Sandbox
- An operating-system boundary that limits what commands the agent runs can touch, such as paths outside the workspace or the network, whatever the model intends.
- Allowlist
- A set of commands or tools pre-approved to run without a prompt; its entries often match by prefix, so a broad entry approves more than it names.
- Plan mode
- A read-only mode in which the agent explores and writes a proposal for approval before it is allowed to change any file.
- Checkpoint
- A local snapshot an agent tool takes as it edits, letting you rewind its file changes, and in some tools the conversation, to an earlier point.
- Hook
- A command the harness runs at a defined event in the agent loop, able to inspect a tool call and, at some events, block it.
- Headless mode
- Running an agent non-interactively from a script or CI job: one prompt in, a result out, with no person present to approve actions.
- Cloud agent
- An agent run on a provider's remote environment from an issue or task, usually delivering its work as a branch and pull request for review.
- Subagent
- A separate agent instance with its own context window, given a narrow task by the main session and returning only a summary of its findings.
- Next edit prediction
- Editor completion that predicts where your next change belongs, not only what to type at the cursor, usually triggered by an edit you just made.
The products differ in surface, but the sections line up around the same handful of mechanisms, and reading them side by side is the fastest way to learn any one of them. **Claude Code is the reference model.** Its subsections split the agent into parts: the [agent loop and its safeguards](/topics/ai-claude-code-agent-loop), [memory and context](/topics/ai-claude-code-context), [hooks](/topics/ai-claude-code-hooks), [skills and commands](/topics/ai-claude-code-skills), [subagents](/topics/ai-claude-code-subagents), [MCP integration](/topics/ai-claude-code-mcp-integration), [unattended automation](/topics/ai-claude-code-automation) and [security and governance](/topics/ai-claude-code-security). Once those parts are clear, each other tool reads as a different arrangement of them. **The terminal agents are close relatives.** Codex and Gemini CLI also load layered instruction files by directory, offer a read-only way to work, gate edits and shell commands behind approval settings, and run headless for scripts. Comparison questions usually ask where their defaults differ and what a trust or sandbox setting actually blocks, so learn each tool's defaults as a set rather than flag by flag. **The editors add two layers on top.** Below the agent sit completions, which predict the next text or the next edit as you type and need no instructions at all. Beside it sit rules and instruction files that can be scoped to paths. Cursor and Copilot both offer a quick, local edit surface for one selection and a broader agent for multi-file work; choosing between them is a recurring junior question. Copilot then extends past the editor to a cloud agent and pull-request review on GitHub, and Windsurf's section is mostly about a rename and an agent migration that moved where its rules and procedures live. **The app builders change who the user is.** Lovable and v0 hold the plan, the code, the preview and the deployment in one place. The agent ideas carry over (a planning mode, project-level knowledge, versions you can revert), but the senior questions there are about the handover: Git sync, the backend and its access rules, sandbox isolation, and which review gate actually stands between a chat and production.
- Agent Loop & Safeguards →
The loop, permission modes, plan mode and rewind: the model of an agent every other section and tool comparison assumes you already have.
- Memory & Context →
What the agent knows at the start of a session and how the window fills, which decides most of the quality you get back.
- Harness Hooks →
Where suggestion ends and enforcement begins: the step from an instruction the model may skip to a check the harness always runs.
- Rules and Context Steering →
The same steering problem in an editor, with rules scoped by path or relevance; a useful contrast before reading the other tools.
- Cloud Agent, Review & CLI →
Agents that work away from your machine and return a pull request, plus automated review, and what each one does and does not approve.
- Unattended Automation →
Headless and scheduled runs with nobody to approve, where defaults, credentials and the runner's isolation matter more than the prompt.
Treating an instruction file as a guarantee; a convention the model skips once is enough to break a rule that needed a hook, a permission or a CI check.
Pre-approving a broad command prefix such as a package manager and forgetting it also approves every script and subcommand behind that prefix.
Accepting an agent's report that the tests pass without reading the diff; a test can be made green by weakening it as easily as by fixing the code.
Relying on checkpoints as history; they undo an agent's local edits, while version control is the shared, permanent record.
Running an unattended agent with approvals off on a machine that holds production credentials or network access the task does not need.
Keeping one session going across unrelated tasks until the context window is full of stale exploration, then blaming the model for drift.
Assuming a built-in security scan or a bot review covers everything; know what it inspects and whether its review counts toward required approvals.
Quoting a mode name, folder or flag from an older release; these products rename modes, files and sometimes themselves within months, so state the version.
Sharing team conventions through personal memories or local settings that teammates never receive, instead of files committed to the repository.
The same choices come up whichever tool a question names, and saying which side you chose and why is usually the answer the interviewer is after. - **Autonomy versus oversight.** Approving every action is safe and slow; approving everything is fast and trusts the model with your machine. The defensible middle is narrow pre-approvals plus a sandbox, widened only where the environment is disposable. - **Always-on versus on-demand context.** A rule in every prompt is reliable and costs context on every turn; a scoped or relevance-triggered rule is cheap and may not load when you needed it. - **Local versus remote execution.** A local agent sees your environment and your credentials; a cloud agent works in a fresh environment and hands back a branch, which is easier to isolate and slower to iterate with. - **Pinned model versus automatic routing.** Pinning makes behaviour and cost predictable; letting the tool route each request trades that predictability for convenience. - **Speed versus ownership.** App builders and broad agent runs produce a lot of code quickly. The cost arrives at review and handover, when someone has to understand, secure and maintain what was generated. - **One tool versus several.** Standardising simplifies governance, sign-in and shared instruction files; letting each engineer choose gets better fit per person and more configuration to keep consistent.
Several shapes recur across the products under different names; spotting them lets you answer a question about a tool you have used less. - **Plan, approve, then build.** A read-only mode explores and writes a proposal, a person approves it, and only then may files change. Claude Code, Cursor, Gemini CLI and Lovable each have a version. - **The nearest file usually wins.** Instruction files are layered from a personal or global level down through the repository, and deeper or more specific files typically take precedence over broader ones. - **Enforce at a boundary the model cannot argue with.** Hooks, sandboxes, permission rules, branch protection and required reviews hold whatever the prompt says. - **Return work as a reviewable diff.** Cloud agents and app builders with Git sync deliver changes on a branch through a pull request, so the team's normal review applies. - **Pull context in on purpose.** Mentions, attached files and explicit codebase search replace the tool's guess about what is relevant when an answer comes back too narrow. - **Undo locally, record in version control.** Checkpoints cover the minutes of a session; commits cover everything after it.
explore
- Claude Code (has its own guide)188 questions
- Setup & Platforms11 questions
- Agent Loop & Safeguards21 questions
- Session Workflow15 questions
- Memory & Context22 questions
- Skills & Custom Commands17 questions
- Subagents & Parallel Work17 questions
- Harness Hooks17 questions
- MCP Integration12 questions
- Personalization & Extensions16 questions
- Unattended Automation23 questions
- Security & Governance17 questions
- Cursor24 questions
- Inline Edit & Ask Mode4 questions
- Agent Modes & Cloud Agents6 questions
- Codebase Search & Ignore Files4 questions
- Rules and Context Steering5 questions
- Models & Tab Completion5 questions
- Copilot28 questions
- Inline & Next Edit Suggestions5 questions
- Chat, Mentions & Prompt Files5 questions
- Agent Mode6 questions
- Context & Instructions6 questions
- Cloud Agent, Review & CLI6 questions
- Codex6 questions
- Gemini CLI6 questions
- Windsurf (Devin Desktop)6 questions
- Lovable6 questions
- v06 questions
- OpenClaw107 questions
- Core Runtime21 questions
- Installation & Upkeep18 questions
- Messaging Apps11 questions
- Persistent Context11 questions
- Proactive Runs17 questions
- Extension Layer17 questions
- Securing the Agent12 questions
questions
377 · 9 sectionsAfter Claude Code deleted a failing test's assertions with Edit to make it pass, how do you rewind and which restore option fits?
basics
~20 sPress Esc twice on an empty prompt, or run /rewind, pick the prompt that started the bad turn, and choose Restore code and conversation: the files and the conversation both return to before that prompt.
In Claude Code, what does plan mode let Claude do, how do you enter it, and what happens when you approve the plan?
basics
~20 sPlan mode lets Claude read files and run exploratory commands to propose a change without editing source. Enter it with Shift+Tab, a /plan prefix or --permission-mode plan; approving the plan exits plan mode into the mode the chosen option names.
In Claude Code, what happens in the gather-context, take-action and verify-results phases, and how do you steer the loop mid-run?
basics
~20 sClaude Code repeats three blended phases until the task looks done: gather context (read, search), take action (edit, run commands) and verify results (tests, builds). Each tool result shapes the next step; Esc stops the running call so you can redirect.
What is the Claude Agent SDK, and when would you embed it in an application instead of scripting `claude -p`?
basics
~20 sThe Claude Agent SDK runs Claude Code's agent loop, built-in tools, permissions, hooks and sessions as a Python or TypeScript library. Embed it when your service needs approval callbacks, in-process custom tools or typed messages; script claude -p for shell jobs.
What does `claude -p` do, and how does a shell script feed it input and tell whether the run succeeded?
basics
~10 sclaude -p (alias --print) runs Claude Code non-interactively: it takes the prompt plus any piped stdin, runs the agent loop, prints the result to stdout, and exits 0 on success or non-zero on failure.
In Cursor, when should a selected function be changed with inline edit (Cmd/Ctrl+K) rather than sent to Agent with Cmd/Ctrl+L?
basics
~20 sUse Cursor's inline edit (Cmd/Ctrl+K) when the change belongs to the selection: one instruction, applied in place, refined by follow-ups. Use Cmd/Ctrl+L when it spans files or needs exploring, so Agent starts with the selection as context.
After renaming a parameter in Cursor, how does Tab propagate the edit across the file and other files, and how do you accept it?
basics
~20 sCursor Tab predicts multi-line edits from your recent edits, nearby code and linter errors: it rewrites the remaining uses, adds missing imports, jumps to the next edit when you press Tab again, and offers other-file edits in a portal window.
Cursor's Agent keeps ignoring conventions saved in `.cursor/rules/api-style.md` — where do project rules live, and why is this file never applied?
basics
~20 sCursor project rules are .mdc files in .cursor/rules, committed with the repository. A plain .md file there is ignored because it has no frontmatter saying when it applies; rename it to .mdc with frontmatter, or put plain markdown in AGENTS.md.
A security lead asks what Cursor uploads to search a proprietary repository — how does Agent find code, and what still leaves the machine?
basics
~20 sCursor's Agent searches with Instant Grep, a regex index built and queried on your machine; Cursor uploads no paths or code to build it and stores no codebase embeddings. File content Agent opens can still go to the model.
A Cursor team on Auto-review allowlisted `npm`, and Agent ran `npm run db:reset` with no prompt — why did nothing stop it, and how should the team set Run Modes?
basics
~20 sUnder Cursor's Auto-review, an allowlisted command runs immediately, outside the sandbox and without the classifier, and the entry npm prefix-matches every npm command, including any script. Narrow the allowlist to exact commands and let everything else go to the sandbox and classifier.
In VS Code with GitHub Copilot, when do you use editor inline chat instead of the Chat view, and what is each one scoped to?
basics
~20 sUse editor inline chat for a quick, targeted edit in the open file: its prompt is scoped to the active editor or selection and comes back as an inline diff. Use the Chat view for multi-step, multi-file work and codebase questions.
Where does GitHub Copilot's repository-wide instructions file live, and how do you confirm Copilot actually used it?
basics
~20 sCopilot reads repository-wide instructions from .github/copilot-instructions.md at the repository root and adds them to every request made in that repository. In VS Code or GitHub.com chat, the file appears in the response's References list when it was sent.
How do you accept, partially accept, cycle or dismiss GitHub Copilot ghost text in VS Code?
basics
~20 sTab accepts the whole ghost-text suggestion and Esc dismisses it; Accept Next Word (Command+Right on macOS, Control+Right on Windows and Linux) takes one word, and Alt+] or Alt+[ (Option on macOS) cycles through alternative suggestions.
What happens when you assign a GitHub issue to Copilot, and how do you change the task once Copilot cloud agent has started?
basics
~20 sCopilot cloud agent works in an ephemeral GitHub Actions-powered environment on a new copilot/ branch, opens a pull request and requests your review. It reads the issue only at assignment; send later changes as an @copilot comment on its pull request.
In VS Code, what do Copilot's agent permission levels — Manual permissions, Assisted permissions and Allow all — each change, and which is the default?
basics
~20 sManual permissions, the default, runs only what your tool, URL and terminal approval settings already allow and asks about the rest; Assisted permissions lets an LLM judge approve calls; Allow all runs every tool call without asking.
In a monorepo, how does Codex decide which AGENTS.md files a session started in services/payments loads, and in what order?
basics
~20 sCodex reads one global file from CODEX_HOME, then walks from the project root down to services/payments, taking at most one file per directory: AGENTS.override.md, else AGENTS.md, else a fallback name. Root comes first, so deeper files win, within a 32 KiB budget.
What does Codex's `codex exec` command do, and what must you add before it may edit files in your repository?
basics
~20 scodex exec runs one Codex task without the interactive terminal UI, streaming progress to stderr and printing only the final message to stdout. It starts in a read-only sandbox, so it edits nothing until you pass --sandbox workspace-write.
In Codex, what does sandbox_mode control versus approval_policy, and what does the default workspace-write plus on-request pairing allow without asking?
basics
~20 ssandbox_mode sets what model-run commands can technically touch; approval_policy sets when Codex stops to ask. With workspace-write and on-request, Codex reads, edits and runs commands in the workspace freely, but asks before writing outside it or using the network.
A CI job runs Codex's codex exec to fix failing tests unattended, and every command that downloads a dependency fails. Why, and how should the job be configured?
basics
~20 sBy default codex exec never asks for approval, and its workspace-write sandbox keeps network access off, so downloads fail back to the model. Install dependencies before Codex runs, enable sandbox_workspace_write.network_access only if needed, and reserve --yolo for an isolated runner.
How do you start a Codex Cloud task from the terminal, and how does its change reach your local checkout or a pull request?
basics
~20 scodex cloud exec --env ENV_ID "task" submits a task to a published Codex Cloud environment; codex cloud is marked experimental in 0.159.3. Review the result in ChatGPT and commit or open a pull request there, or bring the diff home with codex apply TASK_ID.
In Gemini CLI 0.62.0, which GEMINI.md files reach the model, in what order, and how do you see exactly what it received?
basics
~20 sGemini CLI concatenates ~/.gemini/GEMINI.md, the GEMINI.md files from the launch directory up to the repository root, and files found later in folders a tool touches. /memory show prints the combined text; /memory list prints the paths.
In Gemini CLI 0.62.0, what does each --approval-mode value - default, auto_edit, yolo and plan - let the agent do without asking?
basics
~10 sGemini CLI's default mode runs reads and searches but asks before edits and shell commands; auto_edit also approves file edits; yolo approves tool calls wholesale; plan is read-only apart from writing its Markdown plan.
A release job runs `gemini -p "update CHANGELOG.md from the commits since the last tag"` with Gemini CLI 0.62.0 and changes nothing - why, and what do you change?
basics
~10 sHeadless runs cannot ask, so write_file, replace and run_shell_command are denied in the default mode, and the untrusted checkout forces that mode anyway. Trust it with --skip-trust and pick --approval-mode=auto_edit or a policy rule.
You open an unfamiliar cloned repository in Gemini CLI 0.62.0 and choose Don't trust - what does safe mode switch off, and what still works?
basics
~20 sSafe mode ignores the repository's .gemini/settings.json and .env, connects no MCP servers, loads no custom commands, blocks extension installs and forces the default approval mode, so edits and commands ask. The agent can still read code.
A team of forty developers is standardising on Gemini CLI 0.62.0 - which sign-in should they use, and how do you stop anyone using a different one?
basics
~10 sFor company code, use corporate Google accounts on a Code Assist Standard or Enterprise licence with GOOGLE_CLOUD_PROJECT set, or Vertex AI under the company project; enforce it with security.auth.enforcedType in the system settings file.
In Devin Desktop (formerly Windsurf), a repository keeps agent rules in .windsurfrules, .windsurf/rules/ and AGENTS.md: which are still read, and where should new rules go?
basics
~20 sAll three are still read. New workspace rules go in .devin/rules/ as one .md file per rule; that folder is preferred and takes precedence, .windsurf/rules/ is a fallback, .windsurfrules is a legacy single file, and AGENTS.md feeds the same rules engine.
When Windsurf became Devin Desktop on June 2, 2026, what actually changed for a developer's setup, and what stayed the same?
basics
~20 sDevin Desktop is Windsurf renamed by an over-the-air update on June 2, 2026: same editor, features and pricing, settings ported. The surf command became devin-desktop, the app is named Devin, and .devin/ folders are preferred over .windsurf/.
In Devin Desktop's legacy Cascade agent, how do auto-generated memories differ from rules, and why can't a team rely on memories for shared conventions?
basics
~20 sCascade writes memories itself and keeps them locally in ~/.codeium/windsurf/memories/, tied to one workspace on one machine and never committed. Rules are files you write and version. Teammates never see your memories, and the Devin Local agent does not use them.
In Devin Desktop (formerly Windsurf), how does a workspace rule's trigger value decide when the agent sees it, and what size limits apply?
basics
~20 sThe trigger field picks the mode: always_on is in every message, model_decision shows only its description, glob fires on matching files, manual waits for @rule-name. Workspace rule files cap at 12,000 characters, global_rules.md at 6,000.
After a Devin Desktop update, a team that came from Windsurf finds new tabs opening Devin Local instead of Cascade: what stops working, and how should they migrate?
basics
~20 sDevin Local lacks memories, workflows, app deploys and Arena mode; the Cascade Migration Wizard turns memories and workflows into skills. Rules and AGENTS.md keep working, auto-execution levels become allow, ask and deny rules, and MCP tools prompt by default.
In a Lovable project chat, which of Chat, Plan and Build modes can change the app's code, and what do the other two do instead?
basics
~20 sOnly Build mode, previously called Agent mode, changes the app. Plan mode investigates and writes an editable plan you approve, then hands over to Build; Chat mode discusses the project and never changes its code or data.
Lovable projects created in January 2026 and August 2026 — which stack does each run on, and what does upgrading the older one change?
basics
~20 sThe January project runs Lovable's older React + Vite stack; the August one runs TanStack Start, the default for new projects since May 13, 2026. Upgrading converts pages to server-side rendering; the live site changes only on the next publish.
For a new Lovable project, what changes if you connect your own Supabase project instead of using Lovable's built-in Cloud backend?
basics
~20 sOwnership and management move to you: your own Supabase account, billing and dashboard instead of Lovable credits and the Cloud view. You lose Cloud-only features such as in-editor backups and chat-configured auth, and no one-click migration exists either way.
A founder's Lovable prototype is being handed to an in-house team that requires reviewed pull requests on main — how should Lovable's two-way Git sync be set up, and what does the repository not carry?
basics
~20 sLet Git sync create a repository the team owns, keep Lovable on its own feature branch merged through reviewed pull requests, and never rewrite the synced branch. The repository holds code and migration files, not data, secrets or deployments.
A published Lovable app passed its Quick scan, yet any visitor can read every customer's records — which limits of Lovable's built-in scans explain that?
basics
~20 sLovable's Quick scan checks database access rules, npm dependencies and MCP exposure, not application code. Service-role server code bypasses row-level security unseen; the on-demand Deep scan reviews it, and critical findings block publishing only if the workspace enables that.
In a v0 chat connected to GitHub, which branches does v0 create and push to, and what happens to them when you publish?
basics
~20 sA GitHub-connected v0 chat starts from a base branch; its first code change creates a working branch that gets every change as an automatic commit. Publish merges that branch's pull request into the base, and the next change starts a new working branch.
When you ask v0 for a web app without naming a stack, what does it generate, and how reliable is it with another framework?
basics
~20 sv0 defaults to a Next.js app written in React and TypeScript, styled with Tailwind CSS and built from shadcn/ui components. It can use other frameworks, but its docs say Next.js gives the most reliable results.
In v0, a team wants no change to reach production without a teammate's approval. What actually holds back a Publish, and where are the gaps?
basics
~20 sv0's Publish merges the chat's pull request itself, so a teammate's review happens only if the repository requires one on the base branch. Projects without GitHub deploy straight to Vercel, and v0 roles decide who may publish.
In v0, each VM-backed chat runs in a Vercel Sandbox. What does that sandbox isolate, and what can code running inside it still reach?
basics
~20 sA v0 sandbox isolates each chat from other chats, other users and production. Inside it, code can reach the internet (Sandbox Network Policy defaults to allow-all) and the project's Development environment variables, which any terminal process can read.
In v0's Design mode, what happens to your visual tweaks when you click Apply, and where is Design mode unavailable?
basics
~20 sDesign mode tweaks stay pending until Apply sends them to the chat, where v0 generates a new, revertable chat version with the change in source code. It works only on a chat's latest version, on the latest preview runtime.
In OpenClaw, how do `--at`, `--every` and `--cron` schedules differ when you add a job with `openclaw cron add`, and where does `--tz` apply?
basics
~20 s--at fires once, at a timestamp or after a delay like 20m; --every repeats at a fixed interval; --cron follows a 5- or 6-field expression. --tz gives cron expressions and offset-less --at times an IANA zone, and --every rejects it.
In OpenClaw, what is a heartbeat, how often does it run by default, and how does it stay silent when nothing needs attention?
basics
~20 sAn OpenClaw heartbeat is a system-owned automation that runs a periodic agent turn in the main session, every 30m by default (1h with Anthropic OAuth/token auth). When nothing needs attention the agent replies NO_REPLY and nothing is sent.
In OpenClaw, what happens by default when an unknown person direct-messages your bot, and how do you let them in?
basics
~20 sThe default dmPolicy is pairing: an unknown sender receives an 8-character pairing code and the agent ignores the message. The operator admits them with openclaw pairing approve <channel> <code> or the Control UI, within one hour.
In OpenClaw, why does linking WhatsApp need a QR scan from a phone while Telegram needs only a bot token?
basics
~20 sOpenClaw reaches WhatsApp through WhatsApp Web as a linked device of a real phone account, so channels login shows a QR the phone must scan; Telegram has a native bot API, so a BotFather token in config is enough.
In OpenClaw, what is the difference between a skill and a plugin, and when is a skill enough?
basics
~20 sAn OpenClaw skill is SKILL.md instructions for tools the agent already has; a plugin is code the Gateway loads in-process to add tools, channels, providers or hooks. A skill is enough when existing tools can do the work.