Add a Deep Review Mode for Long-Form Expert Workflows

Ideas Feature Requests
, ,
1

I’m a physical therapist, not a developer. I’ve spent 100+ hours building

a clinical case management system (CaseAgent) entirely inside Cursor —
34 active patient cases, structured JSON indexes, a live dashboard,
multi-file atomic write rules, and a dual-version AI learning mechanism.

The three-panel Cursor interface (file manager / content / chat) is
EXACTLY what expert knowledge workers need. The architecture is perfect.

The problem: the in-IDE AI is a reduced-capability model.

When I ask it to reason through complex clinical logic (e.g.,
counterintuitive treatment decisions where structural laxity requires
strengthening rather than relaxation), it fails — wrong reasoning frame,
plausible but incorrect output.

The same question answered by Claude on the web: correct.

So I’m forced into a “Double-Horse Carriage” workflow:

  • Web GPT/Claude → for reasoning
  • Cursor → for file sync and structured writing

I pay for multiple AI subscriptions just to bridge a gap that Cursor
could close.

What I’m requesting:

1. Option to use full-capability model inside the IDE — not a
coding-optimized variant. Expert practitioners (clinicians, lawyers,
consultants, teachers) are willing to pay premium for this.

2. Multi-model internal debate mode — let two models cross-check
each other’s reasoning within the same workflow. For clinical or legal
reasoning, Model A drafts, Model B flags logical inconsistencies.
Not technically impossible — a product decision.

3. Logic Governance as a first-class feature — .cursorrules works
but it’s a prompt-level hack. Domain experts need immutable rule
mounting with system-level enforcement.

4. Real-Time Audio Structuring (the highest-value feature)

This would be transformative — not just for therapists, but for any
professional working in real-time verbal environments.

The workflow:

  • Practitioner starts a session → hits record inside the IDE
  • AI listens in background, extracts structured fields in real time
    (chief complaint, key observations, hypothesis branches, action items)
  • Session ends → structured draft already 70–80% complete
  • Practitioner reviews → AI writes final record and updates all indexes

Who benefits:

  • Therapists / Doctors: session notes done before the patient leaves
  • Lawyers: client meeting → structured case memo, automatically
  • Teachers / Coaches: lesson observation → feedback report, instantly
  • Consultants: client interview → strategy brief, no manual transcription

My current workaround: Record on phone → Gemini transcribes → copy-paste
into Cursor → AI structures. Three manual steps that could be zero.

The bottleneck is not transcription (Whisper/Gemini already solve that).
The bottleneck is structuring — and that requires a reasoning model.
Which brings us back to point 1.

The market argument:

Coding tools compete for ~1% of users (software engineers).
Expert practitioners are a vastly larger market with simpler UI needs
and higher willingness to pay.

The Cursor frame already works for us. The AI inside it just needs to
think, not just autocomplete.

3

Hey, thanks for the detailed feature request, and it’s really impressive that you’ve built a full case management system as a non-developer.

A few things that might help with your current workflow:

On model quality: The models in Cursor are the same base models as on the web (Claude, GPT, etc.), but the system prompt is coding-focused, which can affect reasoning for non-coding domains. Two things to try:

  1. Use Max Mode (toggle in the model picker). It sends requests with extended thinking, which helps with complex reasoning tasks.
  2. Add a detailed .cursorrules file that clearly says you’re working in a clinical or medical domain, not coding. For example: “You are assisting a clinical practitioner. Prioritize medical reasoning accuracy. Do not assume code context.” This can significantly change the model’s behavior.
  3. You can also bring your own Anthropic API key: Cursor Settings > Models. This gives you access to all Claude models directly. More details: Bring your own API key | Cursor Docs

On multi-model debate: There’s a community-built MCP server that does exactly this: AgentChatBus. It lets multiple AI agents cross-check each other’s reasoning inside Cursor via MCP. Worth checking out for your use case. More details: Discussion: Bringing Multi-Agent Debates to Cursor via MCP (AgentChatBus)

On audio or voice: Cursor already has voice input (microphone icon in chat). It’s not the full real-time session structuring you’re describing, but it does handle voice-to-text input natively.

On rules enforcement: .cursorrules is currently the main mechanism. You can also use project-level rules: Cursor Settings (not VS Code settings) > Rules, for more structured governance. Docs: Rules | Cursor Docs

The broader feature request for non-coding expert workflows is noted. Your use case is a good example of where Cursor can expand beyond developers.

Let me know if these workarounds improve the reasoning quality.

1 Like
4

Thanks — this is a very helpful reply, especially the clarification that the base models may be the same, but Cursor’s system prompting is still coding-focused, and that this can affect reasoning quality in non-coding domains.

That point is actually very close to the core of what I was trying to describe.

My own example happens to come from clinical case work, but I do not think this is only a therapist or medical workflow issue. I think it reflects a broader class of professional workflows that are record-heavy, context-heavy, and reasoning-heavy, but are not primarily code generation.

The same pattern shows up in many domains: lawyers reviewing case records and timelines, journalists organizing interviews and fact checks, teachers tracking student observations and progress, social workers managing case notes and follow-up plans, consultants organizing client notes and action items, and researchers working across literature notes, experiment logs, and drafts.

Across all of these workflows, the underlying need is very similar: capture raw material, structure it, compare across records, detect contradictions, preserve context, and support better reasoning over time.

I’m also not approaching this as a casual non-coding user. I’ve already built a fairly structured workflow inside Cursor for long-form review and reasoning-heavy record work. I’m already using detailed .cursorrules, project-level workflow rules, structured templates, event-based timelines, follow-up indexing, dashboard data, discussion files for review, and calibration against GPT-style summaries.

So I fully agree that rules and Max Mode can help, and I’ll keep testing them. But from my experience, once this workflow becomes deep enough, the limitation becomes clearer: the gap is not only prompt control. The gap is that this kind of reasoning workflow is not yet exposed as a first-class product mode.

In other words, today it works through a stack of manual steering: Max Mode, detailed rules, workflow design, and optionally BYO API or MCP tools. That is workable for advanced users, but it still feels like a workaround stack rather than a native path.

The MCP multi-agent approach is interesting as well, but to me it still feels like an advanced workaround. In practice it can also introduce extra setup complexity, and sometimes extra model/API cost, especially if multiple agents are calling external providers. That is useful for experimentation, but it is still different from having a native product mode.

I also understand that Cursor already has built-in voice input on desktop. My point is slightly different: in my actual workflow, the raw input usually starts on a phone, not at a computer.

Right now, I often capture the raw narrative on my phone, use Gemini as a first-pass layer for transcription and rough structuring, and then paste that into Cursor for deeper review, cleanup, consistency checking, organization, and reasoning-heavy work.

So the issue is not whether voice input exists in general. The issue is that the real capture-to-review workflow is still fragmented across tools.

For many real-world professional workflows, desktop is often not the natural capture point. In practice, the entry point is often a phone, immediately after or between sessions, interviews, meetings, field visits, or research activity. So a mobile capture path that feeds directly into the same reasoning workspace would be much more useful than desktop-only voice input for this kind of work.

That is why I think a simple Mode panel could solve a large part of this without changing Cursor’s core identity.

For example:

  • Default / Coding Mode → current behavior
  • Solo / Deep Review Mode → slower, reasoning-first, better for long-form expert review workflows

This would let users explicitly switch workflow style when the task is not primarily code generation, instead of manually recreating that behavior through rules and setup.

So I do appreciate the suggestions. For me, they reinforce the original request rather than replace it: there is room for a native reasoning-first mode for expert review workflows inside Cursor.