How Cursor is Changing the Game for Technical Architects

Overview

Summary of a conversation and demo featuring Joshua (Josh) Ding, Senior Technical Architect at Salesforce, on technical architecture skills, AI’s impact on the architect role, tools he uses (with a focus demo on Cursor), practical use cases, and recommendations.

Context and speakers

• Guest: Joshua (Josh) Ding — Senior Technical Architect at Salesforce (based in Atlanta). Background: started in functional roles, moved into solution/technical architecture, pursuing CTA.
• Host: Nadcoder channel host (referred to in the conversation as Jay / Nadcoder).

Top skills for a Salesforce technical architect (Josh’s view)

1. Ownership — deliver or escalate and collaborate to get things done.
2. Client & relationship management — manage expectations when things go wrong.
3. Team leadership — use people’s strengths; lead multi-role teams.
4. Flexibility & willingness to learn — keep up with rapid changes (AI, platforms).
5. Technical architecture thinking — design for scalability, maintainability, security (not just hands‑on coding).

AI’s impact on the architect role

AI is a force multiplier: it increases efficiency for research, initial design, content creation, and repetitive/administrative tasks.

Key points:

• AI boosts efficiency for research, initial design, content creation, and repetitive/administrative work.
• Soft skills (leadership, client relationships, product judgment) remain essential; AI should be used as an assistant.
• Architects retain responsibility for design quality, security, and architecture choices.
• Guardrails are needed to mitigate hallucinations, incomplete context, and governance gaps.
• Have a strong coder/reviewer to validate and deploy any generated code.

Tools Josh uses and key features

1. Google Gemini (LLM + Canvas)

   • Chat/brainstorming and project assistant (gems) to keep persistent context.
   • Deep research and reporting for synthesizing documentation.
   • Canvas for meeting notes, formatted docs, infographics, and how‑to guides.

2. NotebookLM

   • Notebook interface for PDFs, transcripts, and recordings.
   • Useful for discovery, study aids (flashcards/quiz generation), and synthesizing large source sets (e.g., certification prep or requirements research).

3. Cursor (focus of the demo)

   • VS Code–based AI coding assistant with direct org metadata awareness.
   • Reads org metadata, existing classes, flows, and tests — uses that context to generate code aligned with org patterns.
   • Agent-like behavior: runs multi-step tasks, performs check-only deployments, detects errors, and iterates to fix compile/test failures.
   • Features:
     • Chat/agent UI with model selection, history/past chats, and a focused agent window.
     • Screenshot/image input for error diagnosis.
     • Produces formatted code with comments and test classes (example output was ~289 lines plus tests; full session ~600+ lines).
   • Good for code generation (Apex, flows glue), test generation, troubleshooting, scanning orgs for duplicates, estimation, and migration planning (e.g., profiles → permission sets).
   • Limitations: requires review and validation; may need iterations or additional context.

Live demo (concise)

Use case: Salesforce Field Service — create recurring service crew‑member assignments via a screen flow that calls invocable Apex.

Process shown:

• Provide a detailed prompt plus org‑specific rules/patterns to Cursor.
• Cursor examined existing metadata (classes/flows) and produced an invocable Apex class and test classes.
• Performed a check‑only deploy, found compilation/test issues (e.g., DateTime vs Date), automatically fixed them, and re‑ran until passing.
• Outcome: working proof‑of‑concept code that follows org patterns, with comments and multiple test cases — ready for developer review and refinement.

Key demo takeaways:

• Dramatic time savings for POC/first draft coding.
• Useful for troubleshooting (including analyzing screenshots).
• Valuable for cross‑team visibility to avoid duplicate work.

Practical use cases called out

• Initial solution design and brainstorming.
• Synthesizing discovery recordings and documentation.
• Generating presentations, how‑to guides, and meeting notes (Canvas).
• Rapid POC/prototype coding (invocable Apex, flows).
• Creating/adjusting test classes and running check‑only deployment cycles.
• Troubleshooting errors, including analyzing screenshots.
• Scanning org metadata to avoid duplicate fields/work and for estimation.
• Migration planning (e.g., profiles → permission sets) and permissioning analysis.

Recommendations and caveats

• Everyone building on Salesforce should experiment with these tools (including non‑coders).
• Use AI to speed up design and reduce tedium, but always validate outputs for security, scalability, and org‑specific rules.
• Keep a human reviewer/developer in the loop — AI accelerates work but isn’t a turnkey replacement for expertise.
• Expect iteration when context is incomplete; providing richer org‑specific rules and metadata yields better outputs.

Primary sources / speakers

• Joshua (Josh) Ding — Senior Technical Architect, Salesforce (guest and demo presenter).
• Nadcoder channel host (interviewer; referred to as Jay/Nadcoder).