Skip to content

The Radical IDE Concept: "Cursor for Hardware"

Source files: - Architechture & Research/RapidDraft Studio/Vision/Summary of ChatGPT Radical Idea.md - Architechture & Research/RapidDraft Studio/Vision/Summary of ChatGPT Initial Discussion.md Last synthesized: March 2026

One Line

RapidDraft Studio is an AI-first engineering workflow IDE where the IDE orchestrates end-to-end work and becomes the primary cockpit for mechanical engineering, while CAD/CAE authoring tools remain the places where humans do manual edits.

The Core Reframe

Traditional workflow: Engineer opens CATIA → runs a plugin → gets results → manually reviews.

Radical workflow: Engineer selects a PLM item in RapidDraft → the IDE asks what to do (DFM review, fatigue analysis, clearance check, design review) → runs the workflow → pauses when human input is needed → engineer clicks "Open in CATIA" → fixes the geometry → closes CATIA → the IDE detects the update and resumes automatically.

The shift is fundamental: the IDE is the driver, not CATIA/SolidWorks/HyperMesh.

Why "Cursor for Hardware"

Cursor (the VS Code AI tool) works because: - It makes code development feel like a seamless, automated, traceable process. - You don't leave your editor; the tool orchestrates everything. - You stay in control: you approve every change.

RapidDraft applies this mental model to hardware design: - Everything is an orchestrated, reproducible "run" with versioned artifacts. - You don't leave the IDE; handoffs to native tools feel seamless. - Deterministic checks are the source of truth; AI is the copilot. - Every decision is traceable: what changed, why, who decided, when.

It's not called "Cursor for hardware" because it mimics VS Code's UI. It's called that because it achieves the operating model: engineering work becomes automated, agent-guided, versioned, and traceable—while humans keep authority over edits and decisions.

The Operating Model: Build System for Engineering

Under the hood, RapidDraft behaves like a build system (think Make, Bazel, Cargo) for engineering workflows.

Everything is an Artifact

  • "CAD snapshot from PLM revision X + configuration Y"
  • "Tessellation vN"
  • "Feature graph"
  • "Findings list" (deterministic)
  • "Issues" (collaboration wrapper)
  • "Report" (formatted PDF/HTML)
  • "Release bundle" (evidence package)

Each artifact has provenance: who produced it, from what inputs, using what rules, at what version.

Workflows are Modular and Extensible ("Skills")

  • PLM fetch
  • Translate via CAD translator SDKs
  • Tessellate
  • Feature detect
  • Rule checks (DFM, clearance, etc.)
  • Meshing
  • Solver setup
  • Run analysis
  • Postprocess
  • Compare revisions
  • Generate report
  • Push issues back to PLM

Each step consumes artifacts and produces new artifacts. Reruns are fast (cache), and results are auditable.

Reproducibility is Built In

  • Same inputs + same rules + same version = same outputs
  • Runs are versioned, logged, and never mutated
  • You can replay any run, inspect any step, understand any finding
  • No "black-box magic"; every result links back to measurable data

The PLM-First Entry

RapidDraft integrates with PLM as a first-class entrypoint, not an afterthought.

The user doesn't import STEP files. Instead:

  1. User opens RapidDraft.
  2. User browses/searches PLM items (Teamcenter, Windchill, etc.).
  3. User selects: item + revision + configuration.
  4. System creates an immutable snapshot with metadata (materials, approvals, effectivity, BOM context).
  5. System pulls the native CAD through translator SDKs.
  6. System executes the workflow.

Outputs (reports, findings, issue links, sign-off status, release checklists) can be pushed back as PLM attachments/attributes, keeping governance and traceability in place.

This is what makes the IDE "real" for industry: it fits enterprise governance without forcing a new file workflow.

The Deterministic Truth Layer

Engineers trust engineering because it's measurable, repeatable, and explainable.

Findings are deterministic: - Measured value (e.g., "2.5 mm draft angle detected") - Threshold (e.g., "Minimum 3 mm recommended for plastic molding") - Rule (e.g., "DFM_DRAFT_MIN_V2") - Ruleset version (e.g., "RapidDraft DFM Pack v3.2") - Geometry anchor (e.g., "Face ID 1247 at coordinates [x,y,z]")

AI's role is strictly bounded: - Summarize findings (e.g., "3 priority issues found in undercuts; 12 warnings on thickness") - Prioritize (e.g., "Most costly to fix: undercuts in mold pocket") - Suggest remedies (e.g., "Add 3mm draft to surface XYZ") - Draft review notes (e.g., "This design has good wall thickness but needs draft review") - Generate supplier questions (e.g., "Can you accommodate 3mm minimum draft on these features?")

AI cannot: - Create authoritative findings without deterministic backing - Override engineer decisions - Ask engineers to "trust the AI" on engineering outcomes

The engineer remains the final authority: accept/fix/waive, always with rationale tracked.

Collaboration Built Into Review

Collaboration is not a chat sidebar. It's anchored to deterministic findings.

A "review session" is: - Tied to a specific PLM revision/configuration + ruleset version - Produces an auto-generated findings list (from deterministic checks) - Supports pinned geometry comments (like Figma) - Shows assignments, owners, status, due dates - Supports issue lifecycle: Open → In Progress → Resolved → Verified → Waived - Supports revision follow-up: "What changed since last review?" and "Are previous issues fixed?"

Releases become a visible pipeline: - Checklist (all issues closed or waived) - Sign-offs (who approved, when, what condition) - Diff summary cards (mass change, CoG shift, interface changes, clearance loss) - Exported artifacts (report PDF, findings JSON, evidence package ZIP)

Everything traces back to the run and the deterministic checks.

The Seamless External Tool Handoff

Truly embedding proprietary CAD inside RapidDraft is a licensing/GPU/OS/support nightmare. So the product doesn't try.

Instead, it achieves the radical UX through seamless stateful handoff:

  1. Workflow pauses with explicit intervention request: "Mesh quality too coarse at critical fillet—need manual refinement."
  2. Engineer clicks "Open in HyperMesh" (or CATIA, Creo, whatever's installed).
  3. System launches the native tool with exact context: the geometry, the flagged region, the required boundary conditions.
  4. Engineer fixes the mesh, saves/exports the refined result.
  5. System detects the updated artifact (file watcher or notification).
  6. System validates the output (mesh metrics, boundary integrity).
  7. System resumes the workflow from the paused step, rerunning only affected downstream steps.
  8. Engineer sees new findings and disposes them.

To the engineer, it feels seamless. To the system, it's a clean, auditable contract: "Pause here, get human input, resume with validated artifact."

Later, if it's worth it, deeper integrations (remote GPU streaming, containerized CAD, API-level embedding) can be explored. But they're not required for the radical experience.

The Five-Surface Cockpit

The IDE shell is intentionally IDE-like. It's not a CATIA clone or a 3D viewer with a chat sidebar. It's a workflow cockpit with these core modes:

Left Activity Bar (Always Visible)

  • CAD → Model tree, 3D viewer, geometry context
  • Review → Findings, issue list, collaborative comments
  • Workflows → Workflow canvas, run configuration, execution status
  • AI → Assistant panel, commands, proposals, step guidance
  • Releases → Checklists, approvals, diffs, publication status

Main Editor Area

  • Switches between 3D viewer (CAD mode), workflow canvas (Workflows mode), review diffs (Review mode), report preview (Releases mode)
  • High performance for large assemblies using multi-LOD rendering
  • CAD mode: Model inspector (features, metadata, units, coordinate systems)
  • Review mode: Finding details, severity, assignee, comments, linked issues
  • Workflows mode: Workflow run configuration, parameter overrides, cache status
  • AI mode: Assistant commands, proposed actions, human-needed intervention buttons
  • Releases mode: Release checklist, sign-off trail, approvals

Bottom Panel

Terminal/jobs/logs/artifacts style: - Run status, step state, elapsed time - Logs and error messages - Cached results and previously produced artifacts - Links to published outputs (report PDF, supplier pack ZIP, release bundle)

The Key Principles

  1. Everything is a reproducible "run" producing versioned artifacts (findings, reports, issue updates).

  2. AI proposes, engineers decide, the system proves (measures, thresholds, traceability).

  3. Seamless handoff to native tools with context preservation and auto-resume.

What Makes It Genuinely Radical

Not the VS Code aesthetic. Not the slick UI.

What's radical is the operating model: engineering work becomes an automated, agent-guided, versioned pipeline with traceable artifacts and collaboration baked in, while humans keep authority over edits and decisions.

That's the engineering IDE category: a review/release/workflow OS for physical product development, fed directly from PLM and extensible with deterministic skill packs.

It's not "CAD in the cloud." It's "orchestration for engineering, with native tools as trustworthy partners."