Having extensively used Cursor's agent mode for structured refactoring and feature development tasks, I was initially skeptical that Continue could provide a comparable level of directed, multi-step assistance. The agent paradigm, where the AI systematically breaks down a request into a series of file edits, is a core part of my workflow. This post documents my methodological approach to replicating that functionality within Continue, focusing on practical configuration and prompt engineering rather than abstract praise.
The core realization is that Continue lacks a built-in "agent" button, but its `@` slash commands and context-aware system prompt configuration can be engineered to mimic the behavior. My goal was to achieve a similar outcome: issue a high-level command and have the assistant propose a plan, then execute it step-by-step with my approval, without losing the thread of context. The following steps outline my configuration process.
**Primary Workflow Reconstruction:**
* **System Prompt Engineering:** The key was modifying the `~/.continue/config.json` file to include a custom system prompt for the primary LLM (I use Claude Sonnet). This prompt emphasizes a structured, stepwise approach. It instructs the model to first outline a plan when given a complex task, then proceed to edit files sequentially, summarizing changes and waiting for confirmation before moving to the next logical step. This replaces Cursor's automatic plan generation.
* **Strategic Use of Slash Commands:** I use `@code` for most development dialogues to keep the context focused. For a true agent-like initiation, I begin with a prompt such as, "Please implement a user profile editing feature. First, outline the files you will modify and the steps you will take. Then, proceed step by step." The conditioned system prompt then kicks in.
* **Manual Step Control vs. Automation:** The main divergence from Cursor is the need for explicit user confirmation between major steps. While this slightly reduces automation, it increases oversight. I've found it reduces the incidence of the model going down an incorrect rabbit hole, as I can course-correct at each stage.
* **Context Management:** Continue's context attachments (`@folder`, `@file`) are crucial. I attach the relevant directory at the start of a session to ground the model, mimicking the project awareness Cursor's agent inherits.
**Comparative Analysis of Outcomes:**
* **Quality of Output:** The quality of the final code changes is functionally equivalent, as both interfaces ultimately rely on similar underlying models. The difference lies in the process.
* **Speed of Execution:** Cursor's agent is faster for linear, predictable tasks. Continue's reconstructed method is more deliberate, but for complex tasks, the total time can be similar due to fewer required rollbacks.
* **Control and Predictability:** I rate Continue's engineered approach higher on control. The explicit stepwise approval provides a clearer audit trail of the model's reasoning and allows for incremental feedback, which is superior for intricate refactoring jobs.
**Configuration Snippet for System Prompt:**
I added the following to the `models` section of my `config.json`. The critical element is the `systemMessage`:
```json
{
"models": [
{
"title": "Claude 3.5 Sonnet",
"provider": "openai",
"model": "claude-3-5-sonnet-20241022",
"apiBase": "https://api.anthropic.com",
"systemMessage": "You are an expert software engineer. When presented with a complex task, you MUST first articulate a concise plan listing the files to be changed and the logical steps. Then, execute each step one at a time. After completing a step, briefly summarize what was changed and ask for user confirmation before proceeding. Always maintain full context of the plan and previous steps."
}
]
}
```
In conclusion, while not a perfect one-to-one mapping, Continue is sufficiently configurable to replicate the core agent workflow. It requires an upfront investment in prompt design and a slight adaptation to a more interactive, approval-based rhythm. The trade-off is a greater sense of agency and reduced risk of unwanted automated changes. For those who valued Cursor's agent primarily for its structured thinking rather than its full autonomy, Continue presents a viable and highly controllable alternative.
Support is a product, not a department.
That's a really clever workaround using the system prompt. I hadn't considered modifying the config.json directly to enforce that kind of structured thinking. I'm still figuring out the basics of Continue, so seeing the specific approach is helpful.
Do you find the model reliably follows the step-by-step plan in the system prompt, or does it sometimes still try to output everything at once?
So you've gutted your config.json to jury-rig a feature the other editor just has built-in. And you're happy about that.
The problem isn't getting it to propose a plan. It's getting it to reliably follow that plan three steps later when the context is a mess of previous code blocks. My experience is it'll forget the plan and start hallucinating file paths halfway through.
You're just trading a tested button for a brittle prompt hack.
If it ain't broke, don't 'upgrade' it.
Yeah I'm still figuring this out too, and I've had it just dump a whole answer at once before. Maybe it depends on the model? Which one are you using for this?
I tried a similar system prompt for breaking down a Zapier automation, and it worked okay for the first step but then it got confused on the second. Kinda makes me nervous to rely on it for anything important.