What development with AI assistants looks like in practice (Claude Code, Cursor)

The short answer

Development with AI assistants in practice means that an agent such as Claude Code or Cursor reads, writes and edits code directly in the project repository, while a senior developer defines the task, reviews every change and decides what goes to production. Routine work gets much faster, but responsibility for architecture, security and the result stays with a human.

Below we describe what a normal working day with these tools looks like, where they help the most, and where without a senior they would do more harm than good.

What Claude Code and Cursor are

Both are agentic coding assistants. Unlike a chat window you paste snippets into, they work on the whole project:

• Claude Code by Anthropic runs in the terminal (and can connect to an editor). It reads the repository, proposes a plan, edits files, runs commands and tests, and shows the result for approval.
• Cursor is a code editor with built-in AI. Besides completion and chat it has an agent mode that can make changes across several files and run commands.

The principle is the same: the assistant has access to the code, sees the context and both proposes and carries out changes. That is exactly why it matters who is in charge of it.

One task from brief to deployment

1. A brief in plain language

A client writes, for example: "Shipping over €50 should be free, and the cart should show how much is left." The senior clarifies the brief (all countries? including VAT or not?) and only then hands it to the assistant. A vague brief produces vague code, and AI does not change that.

2. The agent finds its way around the code

The assistant searches the repository and finds the shipping calculation, the cart template and the tests. In someone else's or a legacy project this is the biggest saving: instead of an hour of reading code we have a map in a few minutes.

3. Plan and changes

For larger changes we have the agent write a plan first and approve it. Then it edits the files. The senior watches what it changes and stops it when it starts "improving" things the brief did not ask for.

4. Tests

The agent runs the existing tests and adds new ones for the changed behaviour. With AI, tests matter more than ever, because they are guard rails the assistant cannot talk its way around.

5. Senior review

The senior goes through the whole diff line by line: correctness, security, performance, readability. Nothing reaches production without this step. "Done" from the assistant is a proposal, not a fact.

6. Deployment and verification

The change goes to production and we verify it on the live site or app, not only in tests.

Where AI helps most and where it does not

Task	AI contribution	Senior's role
Understanding unfamiliar code	high	verify the map is right
Routine changes, forms, API calls	high	review and tests
Writing tests and documentation	high	check they test what matters
Refactoring	medium	keep scope and behaviour in check
Architecture and data model	low	a human decides
Security and production data	low	a human decides and is accountable

Practical advice from daily work

• Small steps. One task, one diff. A huge brief like "rewrite the whole module" ends in a change nobody can review properly.
• Project rules in a file. Claude Code reads a CLAUDE.md file, Cursor has its own project rules. Write down conventions, test commands and things that must not be done. The assistant then follows them without being told again.
• No production passwords. The agent works with a local or test environment. We do not give it production access or sensitive data.
• Read the diff, not the summary. AI summaries tend to be optimistic. The truth is in the actual code change.
• Watch out for unnecessary code. Assistants like to add checks, helper functions and comments "just in case". Less code means fewer bugs and cheaper maintenance.

Legacy or someone else's project

A large part of our work is not new systems but websites and applications written by someone else, often years ago and without documentation. This is where agentic assistants help the most. The senior has the assistant explain how the project works, where prices are calculated, where orders come from and which parts are fragile, and then verifies the answers in the code rather than taking them on trust.

The first step with an unfamiliar project is usually to get it running locally and run the tests, if there are any. If there are none, we have the assistant write at least basic tests for the part we are about to change. Only then is the change itself made. It takes a little longer at the start but saves fixes after deployment.

What review catches most often

AI assistants make different mistakes than people. Not typos, but things that look right and do not fit the project:

• Invented functions and parameters of libraries that do not exist in the version in use.
• A parallel solution instead of using what the project already has.
• Database queries inside loops that work on test data and slow the site down in production.
• Missing permission checks on a new form or API call.
• Tests that always pass because they test themselves, not the real behaviour.

An experienced person spots each of these in the diff quickly. Without one, they would reach production.

What it means for the client

You pay for a senior's hours, not for hours of typing code. At €38 per hour excl. VAT, the difference is mainly in how many hours are needed. Indicatively: a small website change around 15 minutes, a simple company website from about an hour, a custom e-shop around 5 hours and an accounting integration roughly a day. Before larger work you always get an estimate; details are on the Pricing page.

If you already have a project you built yourself with AI tools and are now dealing with security, performance or deployment, see our AI code to production service. For new systems there is software development with AI, and if you want to bring AI assistants into your own team, we can help through IT consulting.

Want to try it on your own task?

Send us one concrete task, even a small one. You will see how quickly you get from brief to a deployed change when AI writes and a senior is accountable. Get in touch.