Summary of "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)

Ownership — deliver or escalate and collaborate to get things done.
Client & relationship management — manage expectations when things go wrong.
Team leadership — use people’s strengths; lead multi-role teams.
Flexibility & willingness to learn — keep up with rapid changes (AI, platforms).
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

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.
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).
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).