Now this is what Google “search” output but it did neatly define the different types. I use pair and hint based at work as they self host some models and I still want to get better at what I do.

---

1. Pair Programming (Driver / Navigator)

• How it works: You and the LLM take turns writing and reviewing code, mirroring human pair programming. [1]
• Roles:
• You Drive, LLM Navigates: You write the core logic, and the LLM points out edge cases, syntax bugs, or refactoring ideas.
  • LLM Drives, You Navigate: You outline the architecture or pseudocode, and the LLM scaffolds and writes the boilerplate implementation. [1]
• Best used for: Complex feature design, real-time debugging, and interactive problem-solving. [2, 3]

2. Hint-Based / Socratic Programming

• How it works: Instead of asking the LLM to write the solution, you ask it to act like a mentor or tutor that only gives small conceptual hints or diagnostic questions.
• How to prompt it: "Don’t give me the code. Tell me which function is likely causing this memory leak and give me a hint on how to fix it."
• Best used for: Learning new languages, sharpening debugging skills, and preventing over-reliance on auto-generated code.

3. Spec-Driven & “GSD” (Get Ship Done) Development

• How it works: You write a formal specification (spec file, requirements, and design docs) first, and feed it into an agentic workflow or IDE assistant to build the application step-by-step. [4]
• Best used for: Building greenfield applications, managing multi-file changes, and keeping AI output aligned with a clear product blueprint. [4]

4. Multi-Model Parallel Programming

• How it works: You feed the exact same prompt or task into multiple LLMs simultaneously (e.g., Claude, GPT, and Gemini) inside environments like Cursor IDE, which spins up isolated Git work trees for each model. [5]
• Best used for: Comparing different architectural approaches, edge-case handling, or test-case generation before merging the best solution. [5]

5. Meaning-Typed Programming (Type-Driven LLM Calls)

• How it works: An emerging paradigm (such as research languages like Jack) where LLM invocations are abstracted directly into type signatures and function semantics rather than brittle, hand-crafted prompt strings. The compiler handles prompt construction, type parsing, and retries automatically.
• Best used for: Deeply embedding AI calls (like content generation or game level design) straight into strongly typed application code. [6]

6. Autonomous Agent Loops (“Vibe Coding” / Self-Correcting Agents)

• How it works: You give an AI agent a high-level goal, unit tests, and shell/file access. The agent writes code, runs the test suite, reads the stack trace, self-corrects, and loops until the tests pass.
• Best used for: Writing self-contained scripts, repetitive migrations, and well-bounded bug fixes (e.g., via SWE-Bench style workflows). [4, 7, 8]