Getting Started5 min read

Your First Task

The request → act → approve → complete loop, end to end

You have Nx IDE open on a project folder and a provider connected — time to put the agent to work. This page walks through one complete task loop: request → plan → approvals → diffs → completion. Once you’ve internalized this loop, everything else in Nexgile Code is a variation on it.

Start a New Task

Click the New Task (+) button in the panel toolbar. Each task is a fresh conversation with fresh context — starting new tasks per unit of work keeps the agent focused and your context window healthy. Your previous tasks aren’t lost; they live in Task History.

Check the mode selector in the chat input before you type. New installs default to Architect (planning; edits Markdown only). For an implementation task, click the selector and choose Code. Modes are the agent’s job descriptions — Using Modes has the full picture.

Type a request

Be concrete: name the behavior you want and where it applies. For example:

Add input validation to the login form: the email field must contain a valid
email address and the password must be at least 8 characters. Show an inline
error message under each invalid field and block submission until both pass.

You don’t need to specify every file — the agent will find the form. When you already know the file, pull it in directly with an @ mention (@/src/components/LoginForm.tsx); see Context Mentions. More prompting patterns: Typing Your Requests.

Press Enter, and the loop begins.

What happens next: Plan First

Nexgile Code follows a Plan First discipline on every non-trivial task — it’s built into the agent, not a toggle:

It reads the relevant files. You’ll see prompts like “Nexgile wants to read this file” with the filename. It’s building an accurate picture before changing anything.
It records a todo list. Using its todo tool, the agent writes down the concrete work items — actual deliverables, not process steps. The list appears in chat (“Updated the to-do list”) with a live progress line such as “1 of 3 to-dos done.”
It implements each item in order, checking items off as they land.
It runs one verification pass — a quick check that the work is correct, not an endless self-review loop.
It completes, closing the task with a summary.

If your request is ambiguous, the agent may pause with “Nexgile has a question” and offer clickable suggested answers — pick one or type your own.

Reading and responding to approval prompts

Until you enable auto-approval, every action stops and asks. The primary button tells you what kind of action it is:

Prompt	Primary button	What to check before saying yes
“Nexgile wants to read this file”	Approve	The file is one you’d expect it to need.
“Nexgile wants to edit this file” / “create a new file”	Save	Read the diff — this is the moment that matters.
A terminal command is proposed	Run	The exact command line, cwd, and whether you’d type it yourself.
“Nexgile wants to edit a protected configuration file”	Save	Extra caution — these files govern the agent itself.

The secondary button is always Deny. Denying isn’t rude — it sends the refusal back to the agent, which will adjust course. You can also add a message explaining what you’d prefer.

Reviewing diffs

Edit proposals open as a side-by-side diff of the file: removed lines on one side, added lines on the other. Scan for scope creep (changes beyond what you asked), deleted code that shouldn’t go, and convention mismatches. Click Save to apply or Deny to reject.

Every applied change is also captured as a checkpoint — a “Checkpoint” marker appears in the chat timeline. If you regret an approval three steps later, you can View Diff on any checkpoint or Restore Checkpoint to roll files back. Undo is always one click away.

The completion summary

When the work is done, the agent ends the task with a Task Completed block — a one-paragraph summary of what was done. This is your cue to verify like a reviewer: run the app or tests yourself, and git diff the result if the change matters. The task stays open for follow-ups; completion is a milestone, not a locked door.

Where cost shows

The task header (the collapsible bar at the top of the conversation) tracks spend live: expand it to see Tokens (in/out), Cache activity where the provider supports prompt caching, API Cost in USD, and Context Length — how much of the model’s window the task is using. Costs also appear per task in Task History, so you’ll quickly build intuition for what a task like this costs on your model. To enforce budgets rather than watch them, set the per-task cost and request caps described in Command Guardrails & Limits.

Try a follow-up

The conversation still has full context of what was just built, which makes refinements cheap. Type directly into the same task:

Also validate on blur, not only on submit, and clear the error as soon as
the field becomes valid.

The agent updates its todo list and continues in the same loop: read → plan → edit → approve → complete. When the next piece of work is genuinely unrelated, prefer New Task — fresh context beats a sprawling conversation.

If something goes wrong

Four recovery moves cover almost everything at this stage:

Stop. The Stop button halts the task immediately — use it the moment the agent heads somewhere you don’t want.
Deny and redirect. Deny the proposal and say what you’d prefer. The agent treats it as course correction, not failure.
Restore a checkpoint. If an approved edit turns out to be wrong, open the checkpoint menu in the chat timeline and Restore Checkpoint. Note that checkpoints restore files — they can’t undo a terminal command’s side effects.
Rephrase and retry. If the agent loops on the same failing fix, stop it and restate the task with explicit “do not try X again” guidance.

The complete playbook — pre-task checklist, red flags, recovery table — is in Human-in-the-Loop.