In 2026 an in-editor agent is not news. News is that you can run a sprint on it — or wreck the repo, the secrets, and trust in your own code in a week. This is not a Cursor review. It is the workflow I use on production apps (including Next.js) so AI shortens the work instead of replacing thought.

Autocomplete, chat, agent are not the same

Autocomplete finishes the line. Fine for boilerplate, useless for architecture. Chat explains a file and proposes a patch in view. Agent gets a goal, walks the repo, runs tests, opens a PR. Wider reach means a tighter contract: instructions, context, bans.

The failure mode I see most: dump “build feature X” on the whole monorepo. You get a diff nobody can explain. Start with the narrowest mode that finishes the job.

Plan before implementation

Before the agent touches files: 5–10 sentences on what to ship, what not to touch, and how you will know it works (test, URL, behaviour). In Cursor that is plan / Ask, then Agent. On Next.js 16.3 the agent can read versioned docs from AGENTS.md — you do not paste the framework manual into the prompt. Details: Next.js 16.3 in practice.

A plan that works names files. A plan that fails sounds like an agency pitch deck.

Context engineering

The agent does not “know the project”. It sees what you give it: open tabs, @-files, instructions, MCP, search hits. Rule: limited, current, purposeful context.

Pass 2–4 contract files (type, routing, a similar component), not 40.
Do not paste all of data.ts to change one entry — point at the pattern.
Say what not to read: node_modules, lockfile, dumps, .env.
For UI, give a viewport and a user path, not a 12-frame Figma dump.

Too much context hallucinates from stale comments. Too little invents APIs.

AGENTS.md and project instructions

Keep in the repo what you refuse to repeat: stack, commands, conventions, bans (secrets, never commit .env, no exploit PoCs). Next 16.3 upserts a managed docs block — your rules sit beside it, not inside it.

A good AGENTS.md is one or two screens. A bad one is a culture novel. Skills such as next-dev-loop belong on repeatable procedures: inspect → edit → verify against a running next dev, not “write the whole app”.

# AGENTS.md (trimmed)
- Stack: Next.js App Router, SCSS modules, Vitest.
- Commands: npm run lint, typecheck, test, build (frontend/).
- Never commit .env*, keys, dumps.
- UI: do not invent tokens — see .cursor/rules.
- Data field changes: SQL/migration + mapper + UI together.

Plan → implement → test → review

An 8-point plan you accept.
The agent implements on a branch.
The tests that already live in the repo: lint, typecheck, unit tests, one critical browser path.
Review the diff like a junior you do not know: why this file, does it skip auth, did it leave a token in a log.
Only then commit / PR.

If you cannot explain the diff, you do not merge. “Looks fine” is not review.

Where AI actually saves time

Refactor — rename a type across 15 files when the contract is clear.
Tests — Vitest/Playwright skeletons around an existing function, not “90% coverage” on a blank prompt.
Debug — stack plus two files. The agent guesses less with a log than with a full Sentry dump.
Review — ask for a risk list (auth, XSS, N+1), then verify it yourself.
Docs — a PR changelog from the diff. Not a product manual from an empty prompt.
Research — MCP / docs in node_modules instead of 2023 blog posts. WordPress + AI in the CMS is a different article: what works vs hype.

Working safely with agents

An agent with a terminal is a user with your privileges.

Secrets — .env* in gitignore and in the agent ignore. Do not paste keys into chat “to reproduce”. A redacted key in a transcript lives longer than you think.
NEXT_PUBLIC_* — not a secret. Agents love putting a Stripe key on the client. You catch that.
Auto-run — deny rm, git push --force, migrations, curl | sh. Approve on purpose.
Supply chain — do not accept “add this package” without checking the registry.
Customer data — do not paste production dumps into a cloud model. Anonymise or use a local log.

Shipping without baking secrets into the image: Next.js on a VPS.

Why you still have to understand the code

The model optimises for “looks done”. It does not pay for the incident. It does not remember that Postgres RLS is the only barrier. If you cannot say why this fetch is on the server, that is not review — it is hope.

AI is leverage on code you can maintain. On code you do not understand, it is a debt generator. Same for WP content and plugins — AI in WordPress: what works vs hype.

My sample coding-agent workflow

Mail task: “add five blog posts, PL/EN, same SEO as the rest of the site”.

Read — I open lib/blog/types.ts, data.ts, sanitizer, sitemap, one existing post. The agent gets those paths, not all of src/.
Plan — files to touch, no scheduler, publish dates X, category Y. I accept the plan.
Research — the agent reads official docs (WP, Next); I check dates and CVEs. A hallucinated framework version does not land in copy.
Implement — content plus hreflang in the existing metadata helper. No new CMS.
Verify — lint, typecheck, build, ten URLs, sitemap, JSON-LD. The agent may run commands; I read the output.
PR — diff review for secrets, junk CSS, broken links. Merge only when I can defend every new slug.

The same template works on a product like Księgowy AI: data contract first, then the agent, then a real user path.

FAQ

Should all code come from the agent?

No. Autocomplete and twenty hand-written lines still win for a single hook. Agents start at complexity, not ego.

Does AGENTS.md leak IP?

It is repo convention, not secrets. API keys go in a secret manager and in .env, which the agent should not read.

What about MCP?

MCP into the dev server (logs, compile_route) beats “search the web for anything”. Narrower tools, fewer hallucinations.

Summary

An effective 2026 workflow is tight context, a written plan, repo tests, and review as if the author were a stranger. Cursor is an editor with an agent, not a stand-in tech lead. If you do not understand the generated code, you do not have a feature — you have a ticket with interest.