AI coding assistants

5.1 Generate a Python script using Aider

Aider is a terminal‑based AI assistant that generates code from natural‑language prompts, shows a diff, and creates a Git commit for the change.

Run an Aider session that turns a natural‑language request into a committed Python file

In a terminal, run aider --model sonnet squares.py to start a session, then type the sentence above at the prompt. Write it in any language you like.

1. Open a terminal and execute aider --model sonnet squares.py
2. Type your request in plain English at the Aider prompt
3. Inspect the diff printed by Aider to verify the modifications

• You'll see A new Python file appears in the terminal and a Git commit records the change
• Takeaway Natural‑language prompts become real, versioned code
• Check How does Aider turn a plain‑English request into a committed Python file and record it in Git?
• Cost Aider is free and open-source (Apache 2.0) — there is no subscription. You pay only the third-party LLM's token cost for each request (you bring your own key).

5.2 Give a coding task to an Antigravity agent

Antigravity is a desktop application that runs AI agents which can autonomously plan, code, execute, and self‑correct tasks within a selected project.

Install Antigravity, sign in with a Google account, and give an agent a complete coding task to execute autonomously

Open the new-agent screen, type your task into the prompt box (in any language), and send it. The agent does the work; you just watch.

123 Enlarge

1. 1 Project picker which repo this chat works in
2. 2 Model selector chooses the LLM for responses Why this exists →
3. 3 Create worktree opens a separate workspace branch

Best viewed on desktop — tap Enlarge to read the numbered controls.

1. Download Antigravity as a desktop app for your OS and launch it
2. Sign in using your Google account when prompted
3. On the new-agent screen select a project and keep the model set to Gemini 3.5 Flash
4. Paste your task into the prompt box and click Send
5. Observe the agent plan, write, run and iterate the script until the test passes

• You'll see The agent plans, writes, runs and iterates a script and its test until the test passes
• Takeaway Antigravity lets you delegate whole tasks to an agent that handles planning, coding, execution and self‑correction
• Check What steps let an Antigravity agent plan, write, run and iterate a script until its test passes?
• Cost The For Individuals plan is free ($0/month): Gemini 3.5/3.1/3, Claude Sonnet & Opus 4.6 and gpt-oss-120b, unlimited tab-completions and command requests, with basic weekly rate limits. One task like this costs you nothing.

5.3 Run your first Claude Code task

Claude Code is an interactive CLI tool that generates Python scripts from natural‑language prompts, runs them, and displays their output, awaiting user approval before each change.

Install Claude Code, give it a plain‑English request, and watch it generate, execute and display a Python script’s output

curl -fsSL https://claude.ai/install.sh | bash

You don't write any code yourself — Claude writes the script, shows you what it will create, and runs it once you approve.

1. Open a terminal in any folder and execute claude
2. Log in with a Claude Pro or Max account when prompted
3. Enter the task sentence (for example, “Print the first 20 prime numbers”) at the Claude prompt
4. Confirm with yes when Claude shows the file it will create before it writes and runs the script

• You'll see The first 20 prime numbers printed in the terminal by the script Claude created
• Takeaway Describe the desired outcome and Claude Code will produce real code, run it, and let you approve each change
• Check What does Claude Code do after you enter a plain‑English request and confirm the file creation?
• Cost Claude Code needs a paid Claude plan — Pro ($17/mo annual, $20/mo monthly) is the entry point and includes Claude Code. There is no free tier.

5.4 Execute a Codex task from the terminal

Codex is a command‑line AI coding assistant that creates code from prompts, executes it in the same terminal session, and presents the result.

Install the Codex CLI, give it a plain‑English request and let it generate, run and show a script in one terminal session

curl -fsSL https://chatgpt.com/codex/install.sh | sh

You don't write any code yourself — Codex writes the script, shows you what it will create, and runs it once you approve.

1. Open a terminal in any folder and run codex; on first launch sign in with your ChatGPT account or provide an API key
2. Type the task sentence at the prompt and press Enter
3. Confirm the operation by typing yes when Codex displays the file it will create

• You'll see The first 20 Fibonacci numbers printed in the terminal by a Python script that Codex created and executed
• Takeaway Codex acts as an interactive coding agent you steer with natural‑language prompts and explicit approvals
• Check How does Codex generate, run and show a script after you type a task sentence and confirm the file creation?
• Cost Codex is included with a paid ChatGPT plan (Plus $20/mo, Pro from $100/mo); a Free ($0) and Go ($8/mo) tier exist for lighter use, or pay per token via the OpenAI API.

5.5 Set up GitHub Copilot and accept its first suggestion

GitHub Copilot is an AI pair-programmer that lives inside your code editor (here, VS Code) as an extension — not a separate app and not a terminal tool. As you type, it suggests the next lines as faint ghost text you accept with Tab.

Configure GitHub Copilot in VS Code and watch it complete a line of Python code

Open a new .py file in VS Code and type this comment. Copilot offers a greyed-out suggestion — press Tab to accept it.

1. Install VS Code
2. Add the GitHub Copilot extension from the Extensions view and sign in with a GitHub account
3. Open a .py file and type a comment describing the code you need
4. Press Tab to accept the ghost‑text suggestion

• You'll see Around fifteen lines of pandas and seaborn code appear as ghost text, ready to be accepted with Tab
• Takeaway A plain‑English comment can be turned into working code directly inside the editor
• Check What happens when you type a comment describing needed code and press Tab in VS Code with Copilot enabled?
• Cost Free plan = $0/mo, 2,000 code completions per month plus limited chat and agent usage, with access to multiple models. Code completions don't consume AI Credits. Verified students get unlimited completions free via the GitHub Student Developer Pack.

5.6 Make your first AI‑powered code change

Cursor is an AI‑powered development environment that accepts natural‑language prompts via a chat sidebar, proposes diffs, and applies them to files when approved.

Install Cursor, open a folder, and apply a change described in plain English

Download Cursor from cursor.com, sign in (the Hobby plan is free, no credit card), open or create a project folder, then open the chat sidebar and type your idea — in any language you like.

1. Visit cursor.com, download and install Cursor, then sign in
2. Open a folder using File → Open Folder
3. Paste your prompt into the chat sidebar
4. Review the proposed diff and click Accept

• You'll see A new analysis.py file appears with a complete, commented function and an approved diff
• Takeaway Describe what you want, review the AI‑generated diff, and accept to apply the change
• Check After pasting a plain‑English prompt into Cursor’s chat sidebar and accepting the diff, what change appears in your project?
• Cost The Hobby plan is free with no credit card, including limited Agent requests and limited Tab completions — enough to follow this course's first lessons.

5.7 Run a script with a single command

opencode is a terminal‑based AI coding tool that generates code from English requests, shows a TUI preview of the new file, and runs the script upon approval.

Install opencode, give it a task in the terminal and watch it generate and execute a small script

Run this in any folder. opencode shows you the file it will create and applies it once you approve — type your request in any language you like.

1. Install opencode using npm, Homebrew, Scoop, Pacman or Nix
2. Open a terminal in any folder and run the installed opencode command
3. Approve the change when the terminal UI (TUI) displays the file to be created

• You'll see opencode writes a Python script, shows the file to be created and runs it to print a table, all inside your terminal after you approve the change
• Takeaway plain‑English requests become executable code directly in your development environment
• Check What does opencode do after you run its command, approve the displayed file creation, and watch it execute?
• Cost The opencode tool itself is free and open source. You only pay your model provider for the tokens a session uses (set up in the next lesson) — this first small task is a few cents at most.

5.8 Create a Python script from an English description

Windsurf (Cascade) is a desktop AI assistant that reads task descriptions, proposes code edits in a panel, and can execute the resulting script within your project.

Generate, explain and run a Python script that builds sample data and outputs a CSV file

Download Devin Desktop from devin.ai/desktop (windsurf.com now redirects there — Cognition renamed Windsurf to Devin Desktop in 2026). Open any folder, then open the Cascade panel and paste your task — in any language you like.

1. Install Devin Desktop from devin.ai/desktop and sign in
2. Open any folder, open the Cascade panel, and paste the task description
3. Review the proposed edits shown in the Cascade panel and accept them

• You'll see A working Python script that Cascade wrote, explained, and ran — producing a clean CSV from a self‑created sample file
• Takeaway Cascade turns a description into runnable code across your project
• Check How does Cascade turn an English description into a runnable Python script that creates a CSV file?
• Cost The Free plan ($0/month) includes unlimited Tab completions, unlimited inline edits, and a light agent quota — enough to follow this course, though heavy agent use exhausts it in ~2–3 real coding days.

5.9 Iterate script via chat and revert edits

Aider creates a separate Git commit for each conversational edit, allowing safe experimentation and easy rollback with the /undo command.

Do this first Generate a Python script using Aider

Refine your script through conversation and use a single command to revert any edit safely

Send this as a follow-up in the same Aider session — it keeps editing the existing file instead of starting over.

1. Describe your next change in plain English while the session remains open; Aider applies it and creates a new Git commit
2. Type /undo to revert the last AI‑generated commit
3. Issue one clear request at a time to keep each commit small and easy to review

• You'll see The script updates after each request as separate Git commits, and running /undo restores the previous version instantly
• Takeaway Every conversational edit becomes a Git commit so you can experiment freely knowing /undo will always roll back cleanly
• Check What command lets you revert the last AI‑generated Git commit during an Aider session?
• Cost Each request is one metered call to your chosen LLM; grouping related changes into one clear message spends fewer tokens. /undo is free — it is just a Git revert.

5.10 Guide an AI coding assistant to plan, execute and verify code changes

Antigravity agents require explicit outcome definitions and checks so they can autonomously run code, test it, and iterate until the verification passes.

Do this first Give a coding task to an Antigravity agent

Write tasks that name the desired outcome and a verification step so the agent can run and confirm its work without you in the loop

Send this as a follow-up in the same agent so it builds on the work already done instead of starting over. Use the mic in the prompt bar if you'd rather dictate.

1. DEFINE the goal plus a way to check it such as “add tests and run them until they pass”
2. SPECIFY what changes and where, for example “a second function that fetches a sequence by accession”
3. REVIEW the generated Implementation Plan in the side panel
4. CLICK Proceed to let the agent apply the plan, write code and tests, run them, and iterate until all checks pass

• You'll see The agent extends the existing code in place, planning the change, writing code and tests, running them, and iterating on failures until all tests pass
• Takeaway State an outcome and a check so the agent can run and verify its own work
• Check Why must you define both a goal and a verification step when guiding an Antigravity agent?
• Cost Still on the free For Individuals plan; usage draws down against basic weekly rate limits, so batch related changes into one task rather than many tiny ones.

5.11 Craft precise prompts and steer Claude efficiently

Claude Code follows a read‑plan‑act‑verify loop; providing concrete details and stepwise instructions helps it stay focused and produce accurate edits.

Do this first Run your first Claude Code task

Get better, faster results by being specific, breaking work into steps, and letting Claude explore before it edits

Paste the command into the Claude Code prompt box on the main screen and click Send. Watch that Claude only reads the specified files and stops after each step before proceeding to the next.

1. Specify the request with concrete details, e.g., “fix the parser bug where rows with a missing e-value are silently dropped”.
2. Divide complex work into numbered steps, such as 1) parse the BLAST output, 2) keep the top hit per query, 3) write a CSV and plot an e‑value histogram.
3. Ask Claude to analyse before refactoring, then interrupt with Escape if it heads in the wrong direction.

• You'll see The same task done two ways — a vague prompt that wanders and reads half the repo, and a specific one that lands the change in a couple of file reads
• Takeaway Treat Claude like a capable colleague: say exactly what "done" looks like, let it read first, and stop it early if it drifts
• Check How does breaking a complex task into numbered steps improve Claude Code’s results?
• Cost Tighter prompts mean fewer tokens — vague asks like "improve this codebase" trigger broad scanning; specific asks keep usage (and your bill) down.

5.12 Run a Claude coding session and approve its edit

You ran your first task in the last lesson. This time, slow down and watch how it works. Claude Code is not a chatbot that prints an answer — it runs a loop: it reads, plans, acts with a tool, checks the result, and repeats until the job is done. Give it a small task and narrate the loop as it turns.

Execute a single agentic loop that reads, plans, acts and verifies code changes

In your project terminal, run the command above. When the edit proposal appears, first type /context to view the loaded files and the agent’s plan, then approve the change and watch the verification step.

1. Open a terminal in any project folder and run claude with a tiny verifiable task
2. Watch the agent read the file, propose an edit, and then pause for approval
3. Enter /context to display the files and messages currently loaded by the agent
4. Approve the suggested change using the approval prompt
5. Observe the agent run verification steps and report the final result

• You'll see A request moves from read to plan to act to verify, with a pause at the approval prompt
• Takeaway Claude Code iterates through reading files, proposing edits, awaiting your consent, then confirming the outcome
• Check What are the four stages you observe when running a small task with Claude Code in loop mode?

5.13 Craft precise prompts and guide Codex to iterate

Codex can accept additional artefacts such as images via the --image flag, using them as verification targets to steer focused edits.

Do this first Execute a Codex task from the terminal

Obtain focused code changes by defining clear objectives, providing verification targets, and steering the assistant through successive turns

Paste this into the Codex prompt box on the main chat screen. After sending, watch the diff view – ensure Codex proposes only small edits that resolve the test failures without altering unrelated code.

1. SPECIFY the task and constraints in the prompt input, e.g., “Find and fix bugs with minimal, high‑confidence changes”.
2. ATTACH a verification artefact such as a failing test or expected output using the image flag (-i/--image).
3. ASK for an overview of the project first by typing “Explain this code base to me” into the prompt input.
4. REQUEST the actual change after the exploration, refining the request in subsequent prompts as needed.

• You'll see A concise change that meets the defined success criteria without unrelated modifications
• Takeaway Define success explicitly and give a verifiable target so Codex can iterate toward it
• Check How does attaching a failing test image to the Codex prompt guide its code changes?
• Cost Scoped prompts and a clear "done" signal mean fewer model round-trips — less of your plan's usage per task.

5.14 Observe an agentic coding loop

You ran your first task last lesson. This time, slow down and watch how it works. Codex is not a chatbot that prints an answer — it runs a loop: it reads, plans, acts (an edit or a command), checks the result, and repeats until the job is done. The approval mode decides how often it stops to ask you first.

Watch a single Codex request move through read, plan, act and verify

In your project terminal, start codex with the exact command above. Watch the approval dialog that appears before any edit is applied, and approve it to see the diff and verification step.

1. Open a terminal in your project folder and run codex with a tiny verifiable task
2. Watch Codex read the target file and then propose an edit
3. Approve the suggested change in the approval prompt
4. Observe Codex run its verification step and report the result

• You'll see You watched a single request go read → plan → act → verify, and you approved at least one edit or command
• Takeaway Codex operates as an iterative loop that reads, plans, asks for approval, applies changes and verifies before continuing
• Check What effect does changing the approval mode have on how often Codex stops for your consent?

5.15 Steer autocomplete with comments and Tab

Copilot is an AI coding assistant you use inside your IDE — it watches your comments and code, then offers inline completions as you type. Not a separate app you launch; it lives within the editor environment.

Do this first Set up GitHub Copilot and accept its first suggestion

Produce the exact code you need by guiding inline suggestions with precise comments and function signatures

Type the comment, then start a def line below it — Copilot fills in the whole function body as ghost text.

1. Write a detailed comment that names the input, describes the operation, and states the output shape
2. Enter the function signature (e.g. def count_amino_acids(path):) to trigger suggestions
3. Press Tab to accept the suggested line or block
4. Edit any unwanted suggestion by typing over it and adjust the comment if the suggestion drifts
5. Press Escape to dismiss a suggestion you do not want

• You'll see A complete function appears, built from your comment and signature, ready for you to accept piece by piece
• Takeaway Precise comments and signatures let you control what autocomplete generates
• Check What role does a detailed comment play in shaping Copilot’s inline suggestion after you type a function signature?
• Cost Inline completions are unlimited on Pro and capped at 2,000/month on Free — and completions never spend AI Credits, so iterating costs nothing on the credit meter.

5.16 Use tab autocomplete and file‑aware chat while coding

Cursor combines tab‑based inline completion with a chat sidebar that can read your project files to answer contextual questions.

Do this first Make your first AI‑powered code change

Accelerate writing code with Tab completion and get context‑aware answers from the chat sidebar

Tab completion fires as you type — press Tab to accept a suggestion. The chat sidebar already knows your open files, so you can ask about your code, not generic examples.

1. Start typing a function and watch Tab completion suggest whole lines and functions; press Tab to accept or continue typing to ignore it
2. Open the chat sidebar and ask a question about your project in plain English, letting Cursor read your files to provide a grounded reply
3. Use chat for understanding and targeted edits, and use Tab for moment‑to‑moment typing

• You'll see Autocomplete suggestions appear as you type and the chat returns answers that reference your project's actual files
• Takeaway Tab speeds up line‑by‑line typing while the file‑aware chat lets you ask precise questions about your code
• Check How does opening the chat sidebar while typing a function let Cursor provide both autocomplete and file‑aware answers?
• Cost Both Tab completion and chat draw on your plan's included usage. On Hobby these are limited; Pro ($20/mo) adds generous included usage so you rarely think about it.

5.17 Connect any AI coding model to opencode

opencode lets you choose a model from providers like Anthropic, OpenAI, Google, Mistral or Ollama via its Model Picker UI.

Do this first Run a script with a single command

Link a provider key or existing subscription so opencode can run code generation tasks.

Once a model is connected, hand opencode a multi-step job like this and let it write and run the script.

12 Enlarge

1. 1 provider dropdown select AI provider for code generation
2. 2 default selection label indicates currently selected model

Best viewed on desktop — tap Enlarge to read the numbered controls.

1. Open the Model Picker in the New Session screen and choose a provider such as Anthropic, OpenAI, Google, Mistral or Ollama.
2. Enter your API key in the API Key field that appears for the selected provider.
3. If you have a GitHub Copilot or ChatGPT Plus/Pro subscription, click Log in with Subscription and authorise the connection.
4. Select the specific model you want from the dropdown list and confirm the selection.

• You'll see opencode executing the task using the selected model and producing an output file.
• Takeaway You control which model powers opencode – any of the supported providers, a local Ollama instance, or a subscription you already own
• Check What must you select in the Model Picker before opencode can run a task using an external provider’s model?
• Cost BYOK means token costs land directly on your provider bill — monitor usage or cap spending to avoid surprises. Reusing a Copilot or ChatGPT subscription means no new bill at all.

5.18 Refine a script using Cascade conversations

Cascade (Windsurf) applies edits based on conversational prompts; precise location details ensure targeted modifications without restarting the whole task.

Do this first Create a Python script from an English description

Drive Cascade conversationally to update your code by describing precise, located changes instead of restarting

Send this as a follow-up in the same Cascade conversation — it keeps iterating on the code it already wrote instead of starting over.

1. Specify the exact change and its location in your request
2. Group related tweaks into a single message and let Cascade apply them together
3. Review the suggested edits, accept them, and re‑run the script
4. If feedback is vague, restate the request more precisely before sending another prompt

• You'll see Your existing script is updated in place with the requested modifications while preserving earlier work
• Takeaway You steer Cascade like a teammate by describing outcomes precisely and iterating in small steps
• Check Why is it important to specify the exact location of a change when refining code with Cascade?
• Cost Tab completions and inline edits are unlimited and free on every plan; each Cascade task draws on your agent quota, so batch related changes to make them count.

5.19 Run Aider with automatic linting and testing

Aider can run linting and test suites after every generated change, committing only when those checks pass.

Do this first Iterate script via chat and revert edits

Verify each change Aider makes by having it lint and test the code before committing

Ask for tests as part of your request — Aider can automatically lint and test the code after each change and fix problems it finds.

1. Start Aider with the --lint and --test options so it runs those checks after every edit
2. Observe the lint and test output; if errors appear, let Aider suggest a fix
3. Accept Aider’s proposed fix and allow it to commit the corrected code

• You'll see Aider modifies the file, runs lint and tests, and creates a Git commit only when they pass
• Takeaway Each commit produced by Aider is validated by linting and testing rather than being an unchecked guess
• Check What happens when you start Aider with the --lint and --test flags before each edit?
• Cost Still only LLM token cost; the lint and test steps run locally on your machine and add nothing beyond the model calls Aider already makes.

5.20 Run an AI coding assistant in a separate Git worktree

Antigravity lets you run agents in isolated Git worktrees or directly on the current branch, providing a safety control for experimental edits.

Do this first Guide an AI coding assistant to plan, execute and verify code changes

Choose where an agent runs so experimental work stays isolated from your real branch

In the new-agent screen, open the Local / New Worktree dropdown, choose New Worktree, paste the prompt into the input box and send. Verify the agent creates the exp-worktree folder and runs the tests there before any changes appear on your main branch.

12 Enlarge

1. 1 Model selector which model answers
2. 2 Create new worktree adds a git worktree for isolated changes

Best viewed on desktop — tap Enlarge to read the numbered controls.

1. Open the Local / New Worktree dropdown on the new‑agent screen
2. Select New Worktree to run the agent in an isolated Git worktree
3. Select Local to run the agent on the current branch for trusted edits

• You'll see An agent running against an isolated Git worktree, its changes kept separate from your main branch until you choose to keep them
• Takeaway Treat the worktree‑vs‑local switch as a safety control: isolate experimental agents, run trusted ones locally, and review before merging
• Check How does selecting “New Worktree” versus “Local” affect where an Antigravity agent applies its changes?
• Cost Choosing where the agent runs costs nothing extra — it's a setting on the free plan. The saving is in safety: no half-finished agent work landing on main.

5.21 Create a detailed edit plan with Claude

Claude Code’s plan mode lets you generate and review a step‑by‑step edit plan prior to any file modifications.

Do this first Craft precise prompts and steer Claude efficiently

Generate and approve a step‑by‑step plan before any code is modified

In the claude-code interface, enter the line above in the prompt box; verify the status bar shows plan mode before sending. Claude will return a step‑by‑step plan—ensure no files are edited until you explicitly approve.

1. Press Shift+Tab to cycle permission modes until the status bar shows plan mode
2. Describe the desired change to Claude, for example “Split my single‑file RNA‑seq script into modules and add tests”
3. Review the step‑by‑step plan that Claude produces
4. Choose how to continue by pressing Shift+Tab again to exit plan mode or approve edits

• You'll see A written plan outlining each change you can review and adjust before edits occur
• Takeaway Plan first by entering plan mode, then let Claude implement the approved approach
• Check What does entering plan mode with Shift+Tab enable you to do before Claude makes any code changes?
• Cost Plan mode prevents expensive re-work: Claude proposes the approach up front, so you catch a wrong direction before it writes (and re-writes) files.

5.22 Set Codex approval mode

Codex’s permission settings (Read‑only, Auto, Full Access) control how much autonomy it has before requiring user approval for edits or actions.

Do this first Craft precise prompts and guide Codex to iterate

Choose how much Codex can do on its own before it edits files or runs commands

In the Codex CLI, paste the whole block exactly as shown. After submitting, watch for Codex’s approval prompts for each file creation or edit; you must confirm before it writes utils.py.

12 Enlarge

1. 1 Mode toggle changes IDE operation context
2. 2 Full‑access agent enables unrestricted tool actions

Best viewed on desktop — tap Enlarge to read the numbered controls.

1. Open the terminal and run /permissions to select Read-only, Auto, or Full Access
2. Observe the current policy displayed as untrusted, on‑request, or never, with the sandbox label workspace-write indicating edit scope
3. In the IDE, click the Switch mode dropdown and choose Chat, Agent, or Agent (full access) to align the UI with your CLI selection

• You'll see The same task run two ways — approving each step in a read‑only / on‑request mode, then hands‑off in a fuller mode once you trust it
• Takeaway Match the approval mode to your trust in the task — tight when it's risky, loose when you just want it done
• Check How does the /permissions command influence Codex’s ability to read, write, or execute commands during a session?
• Cost Approval mode doesn't change token cost — it changes how often you're in the loop; looser modes finish with fewer interruptions.

5.23 Explain errors and refactor code with Copilot Chat

Copilot is an AI assistant you use inside your code editor — it lives in the sidebar chat panel and interacts with the files you’re already working on. Not a separate IDE or standalone app you launch.

Do this first Steer autocomplete with comments and Tab

Use the chat panel to diagnose problems and improve code without leaving the editor

Open the Copilot Chat panel, paste or select the relevant code, and ask in plain language — in any language you like.

1. Open the Chat panel from the Copilot icon
2. Select a block of code so the chat has context
3. Ask the assistant to explain an error or suggest a refactor
4. Review the plain‑language response and copy the provided code changes into your file
5. Continue the conversation with follow‑up questions, simpler versions or added comments

• You'll see A plain‑language explanation of the error together with a cleaned‑up rewrite you can insert directly into your file
• Takeaway Chat acts as an in‑editor tutor that explains, debugs and refactors code
• Check What advantage does using Copilot Chat to explain an error provide over reading the traceback yourself?
• Cost Chat, agents, code review, and CLI features DO consume AI Credits (unlike completions). The Free plan includes limited chat usage; Pro ($10/mo) adds $15/mo in GitHub AI Credits.

5.24 Create a multi‑file feature using Agent mode

Cursor’s Agent mode lets a single English prompt produce coordinated changes spanning several project files.

Do this first Use tab autocomplete and file‑aware chat while coding

Generate a complete, runnable feature across several files by prompting the Agent

Switch the chat to Agent mode and send this. The agent reads your project, writes the files, and plans the steps itself — you review the proposed changes before they apply.

1. Enable Agent mode in the chat sidebar
2. Enter your feature description as a prompt and submit it
3. Inspect the generated diff and click Review to accept the changes

• You'll see A finished script with imports, data cleaning and a clustered heatmap spread over the required files
• Takeaway Agent mode converts a concise English request into coordinated code changes across multiple files
• Check What does enabling Agent mode in Cursor’s chat sidebar allow you to generate across multiple files?
• Cost Agent runs consume included usage by request; Hobby has limited Agent requests, so spend them on real features. Pro includes generous usage for Agent and Composer.

5.25 Switch between plan and build modes to control code changes

opencode offers a plan mode for read‑only analysis and a build mode that applies the approved edits, switched with Tab.

Do this first Connect any AI coding model to opencode

Use 'plan' mode to have the agent analyse and propose an approach before it touches a single file — then switch to 'build' to execute

Start in plan mode for this. Press Tab to toggle to build mode once you're happy with the plan.

1. Press Tab to toggle to plan mode
2. Observe the status bar at the bottom of the TUI showing plan mode and read‑only analysis
3. Provide feedback in plain language to refine the plan
4. Press Tab again to switch to build mode
5. Confirm that code changes are applied after switching to build

• You'll see A read‑only walkthrough of the codebase and a proposed approach in plan mode, then real edits once you toggle to build
• Takeaway Think before you act: plan mode reads and proposes safely, build mode executes — one Tab apart
• Check How does toggling between plan and build modes affect when opencode actually writes code to your files?
• Cost Both modes use your model's tokens like any other turn — but planning first usually saves money by avoiding wrong edits you'd have to undo.

5.26 Apply tab completions and inline edits

Windsurf’s tab completion and inline edit features let you make quick local changes without consuming AI quota or launching a full agent session.

Do this first Refine a script using Cascade conversations

Make quick code changes using Tab autocomplete and inline edits without consuming your agent quota

In the windsurf editor, highlight the function definition and type the prompt above; an inline edit will appear. Accept the suggestion with Tab and verify the docstring is inserted without opening a Cascade task.

12345 Enlarge

1. 1 Autocomplete speed how eagerly it suggests
2. 2 Clipboard as context it can read what you copied
3. 3 Supercomplete edits near the cursor, not just the line
4. 4 Tab to Import adds the missing import for you
5. 5 Tab to Jump jumps to the next likely edit

Best viewed on desktop — tap Enlarge to read the numbered controls.

1. Type until a suggestion appears and press Tab to insert the completion
2. Select the code you want to modify and choose Inline edit, then describe the change
3. Confirm the edit by pressing Enter to apply it in place

• You'll see The code updates instantly after pressing Tab or confirming an inline edit, with no quota usage shown
• Takeaway Small, local modifications can be done for free using tab completions and inline edits rather than invoking the agent
• Check What benefit do tab completions and inline edits give you compared to invoking the Cascade agent directly?
• Cost Both Tab completions and inline edits are unlimited and free on every plan, so this is the cheapest way to make small changes.

5.27 Choose the best LLM for your task and budget

Aider supports selecting different LLM providers via the --model flag, allowing side‑by‑side comparison of accuracy, speed and cost against a public leaderboard.

Do this first Run Aider with automatic linting and testing

Run Aider with the most suitable model for accuracy, speed and cost

In your terminal, paste the command exactly as shown. After the assistant finishes, note the token usage displayed; then rerun the same prompt with --model gpt-4.1 to compare cost versus accuracy.

1. Run Aider with a specific provider by adding the --model flag, e.g. aider --model sonnet for Claude Sonnet
2. Execute Aider against free local models via Ollama when you want zero token cost
3. Open the public model leaderboard and compare each model’s success rate and price to decide which one meets your needs

• You'll see Aider completes the same edit using different models while you compare their success rates on the leaderboard
• Takeaway Match the model to the job and let the benchmark guide cost‑effective choices
• Check How can you compare model performance using Aider’s --model flag and the public leaderboard?
• Cost Aider itself is free and open-source (Apache 2.0) — you pay only your model provider's per-token costs. Aider reports the token count and dollar cost of each interaction in the terminal (use /tokens to see the running total for the current context), so you can watch spend live regardless of which model you choose.

5.28 Run Antigravity agents from the terminal

The Antigravity CLI includes a colour‑scheme selector to adjust the terminal UI appearance before entering a task description.

Do this first Give a coding task to an Antigravity agent

Run Antigravity agents from the terminal using the CLI

Launch the Antigravity CLI, pick a colour scheme when prompted, then type a task. The agent replies with the change as a code diff right in the terminal.

12 Enlarge

1. 1 color scheme option select light theme
2. 2 continue button proceed after entering task

Best viewed on desktop — tap Enlarge to read the numbered controls.

1. Launch Antigravity CLI
2. Select a colour scheme with the colour‑scheme picker
3. Enter a task description and press Enter

• You'll see A terminal session where you type a plain‑English task and the agent replies with a reviewable code diff
• Takeaway The same agents can be accessed via a CLI, SDK or managed service beyond the desktop app
• Check What does the colour‑scheme picker let you customise when running Antigravity agents from the CLI?
• Cost The CLI runs on the same free For Individuals plan and the same weekly rate limits — no separate cost for using the terminal instead of the app.

5.29 Create persistent project memory for Claude

CLAUDE.md is a project‑level configuration file that stores coding standards and commands, automatically loaded by Claude at the start of each session.

Do this first Create a detailed edit plan with Claude

Provide Claude with lasting instructions so it follows your standards automatically each session

Open the project’s file explorer, create/edit CLAUDE.md, paste the text above, save, and then launch a fresh claude-code session. Verify that Claude now uses pandas, seaborn, and runs pytest -q automatically.

1. Create a CLAUDE.md file in the project root and add coding standards, favourite libraries and test‑run instructions
2. Edit the file so it contains only essential facts and keep its length under ~200 lines
3. Save the file; Claude will load its contents at the start of every session

• You'll see Claude uses your test command and preferred libraries without additional prompts
• Takeaway Write the rules once in CLAUDE.md and every future session starts already knowing your project
• Check How does creating a CLAUDE.md file affect Claude’s behaviour in subsequent sessions?
• Cost CLAUDE.md is loaded every session, so trimming it to essentials keeps your base context (and per-message cost) small.

5.30 Define project-wide instructions for Codex using AGENTS.md

Codex reads AGENTS.md files placed at repository root, subfolders, or in a user home directory to apply standing instructions with overriding scopes.

Do this first Set Codex approval mode

Codex follows your project's standing instructions automatically

In the file explorer, open or create AGENTS.md at the repository root, paste the text above, then click Save. Verify that Codex shows a confirmation that it has read the new AGENTS.md before your next command.

1. Create an AGENTS.md file in your repository root and add standing instructions such as “Always run npm test after changing JavaScript”
2. Add additional AGENTS.md files in sub‑folders when you need rules that override the broader ones
3. Place a personal ~/.codex/AGENTS.md file for organisation‑wide defaults that apply to all projects

• You'll see Codex runs the test and lint commands and respects your conventions without being reminded each session
• Takeaway Write the project's rules once in AGENTS.md and Codex applies them on every task, in every session
• Check What hierarchy of AGENTS.md files lets you define both global and folder‑specific instructions for Codex?
• Cost One-time setup — the rules ride along every session at negligible cost and save you repeating yourself.

5.31 Use Copilot Agent Mode for multi‑file tasks

Copilot is an AI coding assistant you use in your IDE — it helps you write, refactor, and test code directly within the editor. Not a separate terminal program; it lives inside the development environment as a chat-based extension.

Do this first Explain errors and refactor code with Copilot Chat

Hand Copilot a longer, multi‑step task and let it plan, write, and iterate across several files

Switch the chat picker to Agent mode, then send the task. Copilot proposes changes across multiple files for you to review.

12 Enlarge

1. 1 button accept changes for a file
2. 2 dropdown switches from Agent to automatic mode

Best viewed on desktop — tap Enlarge to read the numbered controls.

1. Select the mode dropdown in the Copilot Chat panel and choose Agent
2. Submit a task that spans several files
3. Review the listed files it changed, then click Keep to accept or Undo to discard each file

• You'll see Copilot reorganising your code across several files at once, with a ‘files changed’ summary and Keep / Undo controls to review its work
• Takeaway Agent Mode tackles work too big for autocomplete — but you stay the reviewer, keeping or undoing each change
• Check What does selecting Agent mode in Copilot Chat enable you to do that autocomplete cannot?
• Cost Agent Mode consumes AI Credits. Free includes limited agent usage; Pro ($10/mo) comes with $15/mo in AI Credits, Pro+ ($39/mo) adds premium models plus $70/mo in Credits. A deep multi-file run costs more than a single chat.

5.32 Run code and let the AI fix errors

Cursor can ingest an exception traceback from the chat, run the code in Agent mode, and propose fixes that you review and accept.

Do this first Create a multi‑file feature using Agent mode

Execute a script, paste any traceback into Cursor’s chat and have the agent automatically diagnose and repair the problem

Paste an error message straight into the chat. In Agent mode Cursor can run the code itself and iterate until it works — installing what's missing and re-running.

1. Run your script in the terminal or IDE
2. If an exception occurs, copy the full traceback
3. Open the Cursor chat window and paste the traceback
4. Switch to Agent mode if not already active
5. Ask the agent to run the code, see the failure, and iterate
6. Review each change the agent proposes and accept the ones that resolve the issue

• You'll see The script runs without errors and displays its intended output after the agent applies the suggested fixes
• Takeaway Paste the error and let the agent run, diagnose, and fix – the iterate‑to‑green loop replaces manual debugging
• Check How does pasting a traceback into Cursor’s chat let the AI fix the error automatically?
• Cost Each fix-and-rerun is an Agent request against your included usage — batching the error and the goal into one message (as above) spends fewer of them.

5.33 Run several agents at once

opencode’s Multi‑session parallelism option enables multiple agents to work concurrently on separate tasks within the same project.

Do this first Switch between plan and build modes to control code changes

Split a big job across multiple agents working the same project in parallel so independent subtasks finish at the same time

Start two separate opencode sessions on the same project and give each its own focused subtask.

1. Activate Multi‑session parallelism in the project settings
2. Create a new session and assign it a narrow, independent task such as testing
3. Create another session and assign it a different narrow, independent task such as documentation

• You'll see Two agents progressing on separate parts of the same project simultaneously, each with full code understanding
• Takeaway opencode scales sideways: fan independent subtasks out to parallel agents instead of waiting on one
• Check What setting lets opencode run several independent agents on different subtasks at the same time?
• Cost Each running session consumes your model's tokens independently — two agents cost roughly twice one, so parallelise jobs that are genuinely independent.

5.34 Fix errors fast with Cascade

Windsurf is an AI coding assistant you run on your desktop — it watches your editor, reads the Problems panel and lets you push issues to Cascade or invoke Explain-and-Fix without leaving the code view. Not a terminal tool you type commands into.

Do this first Apply tab completions and inline edits

Turn an error into a fix without leaving the editor

Open the Problems side panel, then press the Send to Cascade button; verify that the error list appears in the Cascade chat window before proceeding.

1. Open the editor's Problems panel
2. Click Send to Cascade to push all listed issues into the agent conversation
3. Hover or select an error and press Explain and Fix (⇧⌘.) to get an inline explanation and fix suggestion
4. Review the proposed change and accept it

• You'll see Errors from the Problems panel appear in Cascade and single errors are explained and fixed inline before you accept them
• Takeaway You never have to copy an error message out of the editor – send the whole panel or use Explain‑and‑Fix on a single issue
• Check How does the “Explain and Fix” shortcut let you address a single error without leaving your editor?
• Cost Reading and explaining errors happens inside a normal Cascade task, so it draws on your agent quota like any other task; the Free plan covers light use.

5.35 Refactor multiple files together using Aider

Aider builds a code map of callers and definitions across the project, enabling coordinated edits with each change committed individually via Git.

Do this first Choose the best LLM for your task and budget

Apply coordinated changes across a whole project while keeping each edit versioned in Git

Start Aider with more than one file — e.g. aider --model sonnet analysis.py helpers.py — and ask for a change that spans both.

1. Run aider from the terminal, passing all target files or directories as arguments
2. Observe the code map that Aider builds to understand relationships between callers and definitions
3. Instruct Aider to perform the desired refactor; it will edit each affected file and stage the changes
4. Commit each coherent set of edits automatically using the built‑in Git integration

• You'll see Consistent modifications appear in several source files and each change is recorded as an individual Git commit
• Takeaway Aider can map your codebase and edit many related files in one session while preserving a full Git history
• Check What does Aider’s code map show before you request a multi‑file refactor?
• Cost Larger context (more files, the codebase map) means more tokens per request — another reason to pick an economical model from the leaderboard for routine work.

5.36 Spawn and monitor several agents together

Antigravity’s Manager Surface provides a UI to launch and monitor several agents in parallel, assigning each an independent task.

Do this first Guide an AI coding assistant to plan, execute and verify code changes

Run multiple agents in parallel from the Manager Surface

Open the Manager Surface, spawn two agents on these two independent tasks, and watch them work side by side.

1. Open the Manager Surface
2. Assign each agent an independent task
3. Split a large job into subagents when the work naturally divides

• You'll see Two or more agents running concurrently in the Manager Surface, each progressing on its own task
• Takeaway The Manager Surface lets you orchestrate many agents at once instead of handling them one by one
• Check How does the Manager Surface help you orchestrate multiple Antigravity agents simultaneously?
• Cost Parallel agents draw from the same weekly rate-limit pool on the free plan, so they finish a multi-part job faster but don't make it cheaper — for heavy parallel use, Google AI Pro raises the limits (see antigravity.google/pricing for current plan pricing).

5.37 Control Claude sessions with slash commands

Claude Code supports slash commands like /clear, /rewind, /compact and others to manage session context, usage, and permissions.

Do this first Create persistent project memory for Claude

Drive a session with slash commands and keep the context window small so Claude stays fast and cheap.

Enter the text in the claude-code chat input and hit Enter. After sending, use /usage to verify the token count stays low and the context window only contains this task.

1. Open the command palette by typing / to view available commands such as /help, /clear, /resume, and /rewind.
2. Check the current context with /context and token usage with /usage.
3. Clear stale context between unrelated tasks using /clear.
4. Summarise relevant information while preserving important details with /compact.
5. Navigate command history with ↑, autocomplete commands with Tab, and cycle permission modes with Shift+Tab.

• You'll see A session you steer deliberately — clearing between tasks, rewinding a bad change, and keeping the context lean.
• Takeaway A few slash commands — /clear, /rewind, /compact, /usage — keep long sessions fast, recoverable, and affordable
• Check Which slash command would you use to clear stale context between unrelated Claude sessions?
• Cost /clear and /compact directly cut token use; /usage shows where your tokens go (skills, subagents, MCP servers).

5.38 Choose the right Codex model for your task

Codex allows changing models on the fly via the /model command or -m flag, selecting between options such as gpt‑5.5 and gpt‑5.4‑mini.

Do this first Define project-wide instructions for Codex using AGENTS.md

Pick the Codex model that matches speed, cost and capability needs

In a terminal, run the codex -m gpt-5.4-mini refactor.py command to start a session with the faster mini model, then paste the rename request. Watch how quickly it applies the changes compared to the default model.

1. Select gpt-5.5 as the initial model for complex coding and research workflows
2. Switch to gpt-5.4-mini for faster, lower‑cost edits on lighter tasks
3. Change the model with the /model command during a session or by using the -m flag when launching Codex

• You'll see A heavy refactor on gpt-5.5 versus a quick edit on gpt-5.4-mini – capability where you need it, speed where you don’t
• Takeaway Default to gpt‑5.5, drop to gpt‑5.4‑mini for light or fast work, and switch any time with /model or -m
• Check How do you switch from the default gpt‑5.5 model to a faster, cheaper model for a light edit in Codex?
• Cost Model choice is the main cost lever — the mini model is markedly cheaper for routine edits; save the frontier model for hard problems.

5.39 Select a coding assistant model and validate its suggestions

Copilot is an AI coding assistant you use inside your IDE — it suggests code snippets, completions, and whole functions as you type. Not a separate app or terminal tool; it lives as an editor extension you enable within your development environment.

Do this first Use Copilot Agent Mode for multi‑file tasks

Pick a model and confirm each piece of code it generates before accepting it

Use the model picker in the Chat panel to switch models, then ask Copilot to justify its work.

1. Open the Chat panel’s model picker and select the desired model
2. Run the code Copilot generates and compare its behaviour against expectations
3. Ask Copilot to explain its changes and add a small test, then verify the results

• You'll see The task answered by the chosen model, with an explanation you can check line by line and at least one suggestion you correct
• Takeaway You control the model choice and own the verification – Copilot drafts fast but correctness remains yours to confirm
• Check What two actions let you verify a Copilot suggestion before accepting it?
• Cost Premium models live on Pro+ ($39/mo, $70/mo in Credits) and Max ($100/mo, $200/mo in Credits, priority access to new models). Premium-model chat draws on your AI Credits.

5.40 Pick the right model for the task

Cursor’s model picker lets you choose a specific Frontier model or let the system automatically select the best one for the task.

Do this first Run code and let the AI fix errors

Select a Frontier model in Cursor to control answer quality and usage cost

Open the model picker in the chat/Agent bar, select Claude, paste the prompt into the chat input, and click Send. Watch that Cursor applies the changes and that the test run finishes without errors.

1. Open the model picker in the chat/Agent bar
2. Choose a model such as Claude‑4.5‑sonnet, GPT‑5‑high‑fast, or Gemini from the dropdown
3. Select Auto if you want Cursor to decide automatically
4. Observe the cost and context‑window details displayed inline

• You'll see The same request handled by different models, with cost and context‑window details shown inline
• Takeaway Cursor isn’t tied to one model — pick the model that fits the task, knowing it also acts as a cost lever
• Check How does selecting Auto in Cursor’s model picker affect which model handles your request?
• Cost Model selection directly affects spend: a pricier model eats included usage faster. On Pro ($20/mo) you get generous included usage for Auto and Composer to absorb everyday switching.

5.41 Run opencode agent in a desktop app or IDE

opencode can generate a shareable session link, allowing others to join the same AI coding session across desktop or IDE environments.

Do this first Run several agents at once

Start the same opencode assistant from a desktop window or editor and share its session with others

In the opencode desktop window (or IDE panel), type the sentence above into the prompt box and hit Send. After the agent finishes, click Copy link to get the shareable session URL—ensure the diff preview looks correct before confirming the refactor.

1. Choose the desktop app or IDE extension from the opencode download page
2. Enable Privacy mode in the settings to keep your code local
3. Click Generate shareable session link to copy a URL for collaboration

• You'll see The opencode agent appears in a desktop window or inside your IDE, and a link is shown that reproduces the session for anyone you share it with
• Takeaway One agent works across terminal, desktop and IDE while keeping code private and making sessions easy to share
• Check What feature enables you to share an opencode session with collaborators via a URL?
• Cost The desktop app and IDE extension are part of the free open-source tool — you still only pay your model provider for tokens.

5.42 Make Cascade auto‑fix its lint errors

Windsurf is an AI coding assistant you run in your desktop — it sits beside your existing codebase, reads files, runs commands and iteratively writes fixes with you. Not a terminal-only tool; it’s an app you open, not a CLI utility.

Do this first Fix errors fast with Cascade

Run a task and have Cascade correct any lint issues it creates without manual intervention

In the windsurf interface, type the sentence above into the task prompt box and press Enter. Make sure the Auto‑fix switch is turned on; then watch the status bar for a “5 new lint errors” message that disappears as Cascade fixes them.

1. Enter a multi‑file request such as “add an analytics summary to the panel”
2. Watch for the Auto‑fix indicator to appear when lint errors are detected and let Cascade apply the fixes
3. Click Open diff on any edit to view the exact changes before proceeding

• You'll see Cascade reports the lint errors caused by its edits and clears them automatically before completing the task
• Takeaway Cascade catches and removes the lint errors it introduces so the final code is clean
• Check How does Cascade automatically fix lint errors it introduces during a multi‑file request?
• Cost Auto-fix happens inside the same Cascade task, so it uses your agent quota rather than adding a separate charge.

5.43 Provide richer inputs to Aider

Aider accepts images, web page URLs, and voice‑to‑code commands as additional context for generating committed code edits.

Do this first Refactor multiple files together using Aider

Give Aider context using images, web pages, or spoken instructions instead of typing alone

In your terminal, start a session with aider, then paste the above sentence at the Aider prompt and drag‑and‑drop chart.png into the same terminal window to provide the image context. Watch for any clarification questions from the model before it makes changes.

1. Add an image file to aider as context and ask it to implement the shown design
2. Paste a web page URL into aider and request code that matches the page content
3. Activate voice-to-code in aider, dictate your request, and let the model generate the changes

• You'll see Aider processes the supplied image, web page, or voice command and produces committed code changes
• Takeaway Images, web pages, voice and any of the supported languages feed the same Git‑based workflow
• Check What types of non‑textual inputs can you give Aider to generate code changes?
• Cost Still just LLM token cost; image and web-page context add to the tokens per request, so keep references focused.

5.44 Run an agent as a background or scheduled task

Antigravity provides a /schedule command palette where you can define recurring or one‑off background tasks for agents.

Do this first Spawn and monitor several agents together

Let an agent work while you're away — including on a schedule — and check the result later.

Set this up as a scheduled task in the Manager Surface so the agent runs it on a cron without you starting it each time.

123 Enlarge

1. 1 Project selector assigns task to a project
2. 2 Recurrence option runs the job every day
3. 3 Create button saves and activates the task

Best viewed on desktop — tap Enlarge to read the numbered controls.

1. Open the /schedule command palette.
2. Enter a name, project and schedule in the New Scheduled Task dialog.
3. Click Add Scheduled Task to create the recurring job.
4. For a one‑off run, select the task and click Run in background.

• You'll see A task runs on its own and a summary appears when it finishes.
• Takeaway Agents can operate unattended, so you hand off background or cron‑scheduled jobs and review results at your convenience
• Check How do you schedule an Antigravity agent to run automatically at a later time?
• Cost Background and scheduled runs consume the same weekly quota as interactive ones; on the free plan, keep schedules light, or move to Google AI Pro for more headroom (see antigravity.google/pricing for current plan pricing).

5.45 Manage Git operations with Claude from the terminal

Claude Code can perform Git operations such as staging, committing, branching and opening pull requests directly from natural‑language commands.

Do this first Control Claude sessions with slash commands

Run staging, committing, branching and pull‑request creation by describing them in plain English

In the terminal where claude-code is active, type the line above and hit Enter. Then press Shift+Tab to enter acceptEdits mode and review the staged diff with git diff before confirming.

1. Ask Claude in plain English which files have changed, e.g. “what files have I changed?”
2. Tell Claude to commit your changes with a descriptive message, e.g. “commit my changes with a descriptive message”
3. Instruct Claude to create a new branch, e.g. “create a branch called feature/normalize-counts”
4. Request Claude to open a pull request for the new branch when you are ready

• You'll see A clean commit (and optionally a PR) that Claude staged and described for you from a one‑line request
• Takeaway You never have to context‑switch to git — describe the version‑control step and Claude runs it
• Check Which plain‑English request would make Claude stage, commit, and push a new branch with your changes?
• Cost Git operations are ordinary turns — they draw on your plan like any other task.

5.46 Fix failing tests and commit changes with Git

Codex can trace failing tests, propose minimal fixes in controlled checkpoints, and create a pull request containing the reviewed diff.

Do this first Choose the right Codex model for your task

Turn a failing repository into a green build by applying a targeted fix and creating a pull request

In the Codex interface, paste the error line into the prompt box on the main chat screen and press Enter. Watch for Codex’s proposed minimal change and its automated test run confirming the failure is resolved.

1. Describe the symptom or paste the error so Codex can trace it and propose a minimal fix
2. Apply changes using controlled checkpoints to remove dead code, modernise patterns, or run migrations step by step
3. Review the diff and use open pull requests to commit the changes to Git

• You'll see The previously failing test now passes and the change appears as a reviewed pull request ready to merge
• Takeaway Target the failure, apply a minimal fix in checkpoints, and let Codex open a PR for review
• Check What sequence of steps lets Codex fix a failing test and open a pull request for the change?
• Cost Minimal, high-confidence changes mean fewer iterations and less usage than open-ended "fix it all" requests.

5.47 Use Copilot from the command line

Copilot is an AI coding assistant you run in your terminal — describe tasks in plain English and it writes, tests, and debugs code right from the command line. Not a graphical app or IDE extension you click.

Do this first Select a coding assistant model and validate its suggestions

Get code suggestions, testing and debugging directly in your terminal with the Copilot CLI

Run Copilot CLI in your terminal and describe the task — it suggests the command and can run, test, and debug from there.

1. Launch the Copilot CLI in your terminal
2. Enter a plain‑English description of the command or job you need
3. Read the suggested command that Copilot returns before running it
4. Press Enter to execute the accepted suggestion

• You'll see The Copilot CLI welcome screen showing you are logged in and waiting for a task description
• Takeaway Copilot can assist you wherever you work, not just inside an editor
• Check What steps does the Copilot CLI follow to turn a plain‑English task description into a suggested command that you can review and execute?
• Cost CLI features consume AI Credits (like chat and agents), so they draw on your plan's monthly Credit allowance — completions remain the only free-of-credits feature.

5.48 Provide the AI assistant with project files and extensions

The project files, MCPs (Model Context Protocol servers), skills, and hooks configured for Cursor supply real‑code context and external tool integration to its AI assistant.

Do this first Pick the right model for the task

Supply the agent with your codebase, MCPs and skills so its replies are grounded in real project data

In Cursor’s Agent panel, paste the prompt into the chat input box and press Enter. Verify that the agent opens both referenced files before making changes.

1. Reference the relevant files or folders in the Chat so the agent works from your real code
2. Enable the desired MCPs, skills, and hooks in the agent settings to connect external tools
3. Leverage your existing VS Code extension ecosystem while interacting with the agent

• You'll see The chat shows answers that reference actual files and, when configured, invoke external tools via MCPs
• Takeaway Accurate context turns a generic assistant into one that truly knows your project
• Check How does providing file references, enabling MCPs, and linking VS Code extensions affect the relevance of Cursor’s chat responses?
• Cost Context features themselves are about quality, not extra fees; the usual usage metering applies to the model requests they drive. Teams plans add Bugbot agentic code reviews and shared-context cloud agents.

5.49 Use OpenCode Zen’s free tier and cap your spending

OpenCode Zen’s hosted model selection combined with auto‑reload, a top‑up amount, and a per‑workspace monthly usage cap controls cost while providing free‑tier AI coding.

Do this first Run opencode agent in a desktop app or IDE

Run hosted models on OpenCode Zen for free while automatically limiting spend

In the terminal, start an OpenCode session (e.g., opencode) and paste the sentence exactly; the assistant will apply the free‑tier model, disable auto‑reload, and enforce the $5 limit. Watch the confirmation messages to ensure the settings are applied.

1. Select OpenCode Zen as the model provider
2. Enable auto-reload and set the top‑up amount to $20
3. Set a per‑workspace monthly usage limit of $5

• You'll see OpenCode Zen runs a free‑tier model with auto‑reload and monthly limits applied
• Takeaway Zero‑setup hosted models let you start free and control costs with built‑in limits
• Check What configuration lets OpenCode Zen run a free‑tier model while automatically limiting monthly spend per workspace?
• Cost Zen is pay-as-you-go per 1M tokens with a free five-model tier; paid models span $0.14/$0.28 to $10/$50 per 1M tokens. Auto-reload and per-member limits keep costs in check.

5.50 Revert a change with one click

The revert arrow icon in the Cascade chat panel rolls back a selected step, restoring the codebase to its prior version with one click.

Do this first Make Cascade auto‑fix its lint errors

Experiment fearlessly by rolling back any agent modification instantly.

In the agent output pane, approve the change so it creates a checkpoint. Then click the Rollback button next to the latest checkpoint in the Checkpoints panel to revert the file back to its original state.

1. Open the Cascade chat panel and locate the step you want to undo.
2. Click the revert arrow icon next to that step.
3. Confirm the rollback when prompted.

• You'll see Your project returns to its previous state after clicking the revert control.
• Takeaway Every agent edit can be undone in a single action
• Check Which UI control lets you instantly undo any Cascade edit and return the project to its previous state?
• Cost Reverting to a checkpoint costs nothing — it's a local snapshot, not a new agent task.

5.51 Choose a model and review an agent’s artifacts

The model selector chooses the AI backend (e.g., Gemini 3.5 Flash or Claude Sonnet) while the Artifacts panel displays generated task lists, screenshots and walkthroughs for review.

Do this first Guide an AI coding assistant to plan, execute and verify code changes

Select the appropriate model and verify the agent’s actions by reading its artifacts

In the model selector dropdown choose gpt‑oss‑120b, send the request, then click the Artifacts tab that appears after the run; watch for a complete task list and at least one screenshot before commenting.

1. Open the model selector and pick the desired model such as Gemini 3.5 Flash or Claude Sonnet
2. Run the task with the selected model
3. Open the Artifacts panel to view the generated task list, screenshots and browser walkthrough
4. Add a comment on any artifact that needs correction
5. Submit the feedback so the agent updates its work

• You'll see The task runs using the chosen model and displays Artifacts – a task list, screenshots and a browser walkthrough – ready for comment
• Takeaway Match the model to the task and use Artifacts as your review surface to stay in control of agents that act on your code
• Check How does selecting a model and then opening the Artifacts panel help you verify an Antigravity agent’s work?
• Cost All listed models are available on the free For Individuals plan ($0/month). For higher rate limits and a flexible AI credit pool, there are Google AI Pro and Google AI Ultra paid tiers — see antigravity.google/pricing for current pricing.

5.52 Choose the right model and monitor cost

The /model command switches Claude’s model (e.g., Sonnet or Opus), /config sets a default model, and /usage reports a token breakdown by skill, subagent and time window.

Do this first Manage Git operations with Claude from the terminal

Pick the appropriate Claude model for each task while keeping spending visible.

Paste the whole block into the Claude Code chat input and press Enter. Verify the model switch by checking the banner now shows Opus, then watch for any token‑usage warnings after execution.

1. Run /model to change the model mid‑session; select Sonnet for most work or Opus for demanding tasks.
2. Open /config and set your preferred default model so future sessions start with the right choice.
3. Execute /usage to view a token breakdown by skill, subagent, and server, toggling between 24‑hour and 7‑day windows.

• You'll see The terminal shows which model is active and a usage breakdown indicating where tokens are consumed.
• Takeaway Prefer Sonnet for routine coding, switch to Opus for complex reasoning, and check /usage regularly to avoid surprise costs
• Check What commands let you change Claude’s active model mid‑session and monitor token usage to keep costs visible?
• Cost Model choice is the biggest lever — Sonnet for most work, Opus only when needed; /usage keeps spend visible.

5.53 Run Codex inside your IDE

Installing the Codex extension adds a sidebar where open files, selections and @file references supply context, while a cloud off‑loading option sends heavyweight tasks to remote execution.

Do this first Fix failing tests and commit changes with Git

Execute Codex in the editor, using full file context and optionally sending long jobs to the cloud

In the Codex sidebar, type the task into the prompt box and press Enter. Ensure the @file data.csv reference appears exactly as shown so Codex includes the file context; watch for the generated function to be inserted at the cursor location.

12 Enlarge

1. 1 Codex sidebar opens Codex panel
2. 2 extensions tab install Codex extension

Best viewed on desktop — tap Enlarge to read the numbered controls.

1. Install the Codex extension from the VS Code Marketplace
2. Open the Codex sidebar and add context with open files, selections, and @file references
3. Offload longer jobs to a cloud environment from the sidebar

• You'll see Codex working in your editor sidebar against the files you have open, with a long task handed off to the cloud
• Takeaway IDE extensions can feed the assistant full editor context and let you shift heavy work to the cloud
• Check What steps enable you to run Codex inside VS Code, add file context, and offload longer jobs to the cloud?
• Cost The IDE extension uses the same plan and usage as the CLI — no separate charge for running it in your editor.

5.54 Assign an issue to Copilot

Copilot is an AI assistant you engage through GitHub’s web interface — you assign it to issues just like a teammate and review its pull-request suggestions before merging. Not a local IDE plugin you run from your terminal.

Do this first Use Copilot from the command line

Assign a GitHub issue to Copilot and let it work the task like a teammate

On a GitHub issue, open Select assignees and pick Copilot the same way you'd assign a person.

1. Open an issue on GitHub and click Select assignees
2. Pick Copilot (or another listed AI) from the assignee list
3. Review the changes proposed by the assigned agent and merge when satisfied

• You'll see Copilot appears as an assignable AI agent in the GitHub “Select assignees” menu alongside human teammates and other agents
• Takeaway You can treat Copilot as a teammate you assign work to while retaining review responsibility
• Check What process lets you assign a GitHub issue to Copilot and then review its pull‑request suggestions before merging?
• Cost The coding agent consumes AI Credits. Org plans price per seat: Business = $19/seat/mo, Enterprise = $39/seat/mo; individual paid tiers include a monthly Credit allowance.

5.55 Pick the right Cursor plan and claim a free student year

Choosing a plan on the Pricing page and confirming a .edu email in Account Settings activates the complimentary Student Plan, providing a full year of Pro features at no cost.

Do this first Provide the AI assistant with project files and extensions

Select a suitable Cursor subscription and activate the complimentary Pro year for eligible students

Open the new-agent screen in Cursor, paste the sentence above into the prompt box, and click Send. Verify that the response lists your plan tier, usage limits, and instructions to claim the student offer if applicable.

1. Open Pricing in the main navigation to view all subscription tiers
2. Compare the features listed under each tier and note the included usage amounts
3. If you are a student, navigate to Account Settings, click Verify Status, and follow the prompts to confirm your .edu email
4. Confirm the free year activation on the Student Plan banner that appears after verification

• You'll see A clear map of which plan fits your usage, and — if you're a student — a free year of Pro applied to your account
• Takeaway Start free, upgrade to Pro when the limits bite — and if you're a student, get a full year of Pro at no cost
• Check How does selecting a subscription tier and verifying student status grant you a free year of Cursor Pro?
• Cost Free to start on Hobby; $20/mo for Pro; free for one year for eligible students. Because different models have different API costs, model choice is what governs how fast included usage is spent.

5.56 Choose the right plan and model

The Agent Command Center’s Pricing link shows tier details, while the Base Model dropdown in Cascade selects the underlying AI model that powers the assistant.

Do this first Revert a change with one click

Select a pricing tier and AI model that match your coding workload

Enter this text in the Agent Command Center prompt box and click Send; watch the response table to see quotas and model lists for each tier.

1. Open the Agent Command Center Kanban board
2. Click the Pricing link to view detailed tier information at devin.ai/pricing
3. In Cascade, open the Base Model dropdown and pick the model you need

• You'll see The Agent Command Center shows the current plan, quota usage and available models
• Takeaway Start on Free and upgrade only when agent quota becomes the bottleneck
• Check Which steps let you pick a pricing tier and then choose a base model for Cascade within the Agent Command Center?
• Cost Free $0 · Pro $20/month · Max $200/month · Teams $80/month + $40/seat · Enterprise custom. Pro+ adds extra usage at API pricing; check devin.ai/pricing for the latest.

5.57 Pull external data into a coding session

The /mcp command enables or disables Model Context Protocol servers, and /context lists the active tool names, allowing Claude to read specifications from services like Google Drive.

Do this first Choose the right model and monitor cost

Bring outside services like design docs or tickets into Claude Code using the Model Context Protocol

Paste the two lines sequentially into the Claude Code chat input (press Enter after each line). First ensure the Jira server is enabled, then ask Claude to retrieve the ticket—watch for the confirmation that the Jira tool was loaded in context before the summary appears.

1. Run /mcp to display all configured MCP servers and toggle each one on or off
2. Use /context to view which tool names have been loaded into the current session
3. Disable any unused servers in /mcp to keep the context focused on the tools you need

• You'll see Claude reads a spec from Drive (or another service) inside the same chat where it writes code
• Takeaway MCP connects your real tools and data to every Claude session once you register a server
• Check How does toggling MCP servers with /mcp and viewing loaded tools via /context bring external data into a Claude Code session?
• Cost MCP tool definitions are deferred, so an idle server costs almost nothing; disable unused ones with /mcp to keep context lean.

5.58 Delegate tasks to Codex cloud

Opening codex.com, tagging @codex on an issue or PR, and setting up the cloud environment (repo, setup steps, tool permissions, internet access) delegates execution to Codex cloud.

Do this first Run Codex inside your IDE

Hand long or parallel tasks to Codex cloud and review the results as pull requests

In the GitHub web UI, open an existing issue or create a new one, paste the line above into the comment box, and click Comment. Watch for Codex to open a pull request with the new workflow file.

1. Open chatgpt.com/codex in your browser
2. Tag @codex on an issue or pull request in GitHub
3. Configure the environment in Codex cloud, specifying the repository, setup steps, tools and whether Codex may reach the public internet

• You'll see A finished pull request appears that you can review and merge
• Takeaway For work that doesn't need you watching, delegate to the cloud — Codex runs it in the background and comes back with a PR
• Check What workflow lets you delegate a long task to Codex cloud by tagging @codex on GitHub and configuring repository access?
• Cost Cloud tasks draw on your ChatGPT plan's usage; running several in parallel uses proportionally more.

5.59 Delegate side tasks to a subagent

A subagent is defined by a markdown description placed in the .claude/agents folder; selecting it in the Subagent dropdown routes the side task to that agent, returning only a concise summary.

Do this first Pull external data into a coding session

Move noisy searches, log reads or test runs into a separate agent so the main conversation stays focused

Paste this into the main chat input of the claude-code interface and press Enter. Watch that only a brief summary appears in the main thread while the detailed test output is handled by the subagent.

1. OPEN the Explorer pane and navigate to the .claude/agents/ folder
2. CREATE a new markdown file for the subagent and type its description at the top of the file
3. IN the Claude Code panel, SELECT the newly created subagent from the Subagent dropdown and SEND your side‑task

• You'll see The subagent completes the heavy work and returns only a brief summary in your main thread
• Takeaway Hand bulky operations to a subagent and receive just the answer you need
• Check How does creating a markdown file in .claude/agents and selecting it from the Subagent dropdown move side tasks away from the main conversation?
• Cost Subagents control cost by keeping verbose output in their own window and by routing simple work to faster, cheaper models like Haiku.

5.60 Connect your tools to Codex using MCP

Adding a STDIO or streaming‑HTTP server definition to ~/.codex/config.toml and registering it with the codex mcp command enables Codex to invoke that external tool mid‑task.

Do this first Delegate tasks to Codex cloud

Extend Codex with external tools and data through the Model Context Protocol

In the Codex chat window, paste the sentence above into the prompt box after starting a session (e.g., via codex start). Watch that Codex invokes the external MCP tool and returns the temperature output.

1. Edit ~/.codex/config.toml to add a STDIO or streaming-HTTP MCP server definition
2. Run the codex mcp CLI command to register or manage the new server
3. Start a Codex session; the configured MCP servers launch automatically

• You'll see Codex calls a connected MCP tool mid‑task, using data or actions that live outside your codebase
• Takeaway MCP plugs your own tools into Codex — configure a server once in config.toml and every session can use it
• Check What configuration changes let Codex call an external MCP tool during a session after editing its config.toml and running codex mcp?
• Cost MCP adds capability, not a separate fee — you still pay only for model usage on your plan.

5.61 Create reusable workflow skills

A SKILL.md containing step‑by‑step instructions is stored under .claude/skills//; the resulting slash command (e.g., /clean-fastq) runs that procedure on demand.

Do this first Delegate side tasks to a subagent

Convert a repeated set of instructions into a reusable Skill your whole team can invoke

In the Claude Code interface, paste the command into the main prompt box and press Enter. Watch for Claude confirming the new /review-pr skill and showing the generated SKILL.md content.

1. Create a SKILL.md file in the .claude/skills// folder containing your instructions
2. Save the file to add the new skill to Claude’s toolkit
3. Invoke the skill by typing its slash command, such as /clean-fastq, in any chat

• You'll see A custom slash command – for example /clean-fastq – that runs your exact procedure on demand
• Takeaway Write the steps once as SKILL.md and call them forever with a slash command
• Check How does placing a SKILL.md file in .claude/skills and invoking its slash command provide reusable workflow automation?
• Cost Skills load on-demand, so moving long procedures out of CLAUDE.md and into Skills keeps your base context (and cost) smaller.

5.62 Run Codex from a script or CI pipeline

The codex exec command executes a prompt headlessly, with --json for machine‑readable streams or -o to write results directly to a file, suitable for automation.

Do this first Connect your tools to Codex using MCP

Execute Codex headlessly and capture its output for automation

In a terminal, paste the command and press Enter. After it finishes, verify that release-notes.md appears in the current directory with the generated notes.

1. Execute codex exec "…" with your prompt to run Codex non‑interactively, e.g. codex exec "summarise the repository structure"
2. Add the --json flag to receive a machine‑readable stream or use -o to write the final output straight to a file
3. In CI, invoke the official Codex Action in your workflow instead of handling API keys manually

• You'll see Codex runs without the interactive UI and writes the result directly to stdout, which you can redirect to a file
• Takeaway codex exec makes Codex usable in automated workflows and piping chains
• Check What command line options allow you to run Codex non‑interactively and capture its output for CI pipelines?
• Cost Each codex exec is its own run and bills like any task; keep the prompt focused for CI.

5.63 Run custom commands automatically with Hooks

A hook entry such as "PreToolUse" with a Bash matcher is added to the project’s settings.json; saving triggers the defined command (e.g., a formatter) each time an edit occurs.

Do this first Create reusable workflow skills

Execute your own shell commands before or after Claude's actions such as formatting, linting, or filtering output

Open the settings.json screen in Claude Code, paste the line above into the file, save it, then trigger any Claude action and watch the filtered log appear in the output pane.

1. Open settings.json in your project
2. Insert a hook definition, for example a "PreToolUse" entry with a Bash matcher that filters test output
3. Save settings.json and make a code edit to trigger the hook

• You'll see Your formatter or linter fires automatically on every edit without any reminder
• Takeaway Hooks turn a manual step into a guaranteed command that runs at the right moment
• Check How do you define a PreToolUse hook in settings.json so that a formatter runs automatically on every code edit?
• Cost A pre-processing hook (e.g. grepping a log for ERROR) can slash the context Claude reads, directly lowering token cost.

5.64 Select a Codex subscription plan

Visiting the ChatGPT pricing page, selecting the Plus plan for regular work, and upgrading to Pro if limits are exceeded aligns the subscription with coding demand.

Do this first Run Codex from a script or CI pipeline

Pick the plan that matches how hard you'll use Codex

Paste this into the Codex chat input on the main conversation screen and hit Enter. Verify that the response includes a clear table with each tier’s cost and rate‑limit details.

1. Open the ChatGPT pricing page in your browser
2. Choose the Plus ($20/mo) plan for regular coding sessions and click Select Plan
3. If you exceed Plus limits, upgrade by clicking Upgrade to Pro and confirm the Pro (from $100/mo) selection

• You'll see A clear match between your usage and a tier — Plus for regular study work, Pro only if you hit its limits
• Takeaway Start on Plus (or Free/Go to try it); move up only when rate limits, not the tool, are what slows you down
• Check What steps let you choose a Codex subscription plan that matches your expected usage and upgrade only when limits are reached?
• Cost Plus $20/mo · Pro from $100/mo · Go $8/mo · Free $0 · Business pay-as-you-go · Enterprise/Edu custom — plus API pay-per-token as an alternative.

5.65 Run Claude Code as a headless command‑line tool

Running claude -p "query" processes a single prompt; piping input (e.g., git diff output) into this command lets Claude read, analyze and emit results, functioning as a Unix‑style utility.

Do this first Run custom commands automatically with Hooks

Execute Claude Code non‑interactively and pipe data through it for scripts or CI

In a terminal, run the command exactly as shown; observe Claude's output for any security warnings and redirect it to a file if needed.

1. EXECUTE claude -p "query" to run a single prompt and exit
2. PIPE input into Claude Code, for example tail -200 app.log | claude -p "flag any anomalies"
3. CHAIN Claude Code with other commands in scripts or CI, such as git diff main --name-only | claude -p "review these changed files for security issues"

• You'll see Claude Code acting as a filter that reads piped input, performs the requested task, and writes the result to standard output
• Takeaway Using -p turns Claude Code into a Unix‑style utility you can embed in any automation pipeline
• Check How does using the -p flag with Claude enable it to act as a filter in pipelines, such as reviewing changed files from git diff?
• Cost Headless runs bill like any session; keep prompts focused since each -p call is its own task.