Domain-Specific Prompting (Code, Legal, Medical)

The Problem:

Generic prompts produce generic answers. When you ask an LLM to "write a contract," you get something that looks like a contract but would make any lawyer cringe. When you say "diagnose this patient," you get textbook definitions, not clinical reasoning. Domain-specific prompting bridges this gap.

Think of it like the difference between a general physician and a cardiologist. Both are doctors, but when you have a heart problem, you want the specialist. Domain-specific prompting turns your LLM into a specialist.

Real-World Analogy - Indian Legal System:

If you tell a junior lawyer "draft a reply," they might write a general letter. But if you say "Draft a written statement under Order 8 Rule 1 CPC, denying para 3 of the plaint, raising limitation defense under Section 3 of the Limitation Act," they know exactly what format, language, and legal provisions to use. That is domain-specific prompting.

Key Principles of Domain Prompting:

• Domain Vocabulary: Use the exact terminology the domain uses (e.g., "tort" not "wrongdoing", "idempotent" not "can run multiple times")
• Professional Standards: Reference specific standards, frameworks, or guidelines the domain follows
• Output Format: Match the format professionals expect (legal pleading format, medical SOAP notes, code with tests)
• Risk Awareness: Highlight domain-specific risks and edge cases the LLM must consider
• Verification Hooks: Include checkpoints for domain experts to verify critical outputs

The Code Prompting Framework:

Good code prompts include: language and version, coding style (functional vs OOP), error handling approach, performance constraints, and testing requirements. Without these, you get demo code, not production code.

Code Prompt Checklist:

• Context: What is the broader system? What framework/library versions?
• Requirements: Exact input/output specs, edge cases to handle
• Constraints: Performance requirements, memory limits, compatibility needs
• Style: Naming conventions, design patterns, linting rules
• Testing: What tests to include, coverage expectations
• Documentation: Inline comments, docstrings, README sections

Bad vs Good Code Prompt:

Advanced Code Prompting Techniques:

• Rubber Duck Debugging: "Explain this code line by line, then identify the bug"
• Test-First: "First write the test cases, then implement the function to pass them"
• Code Review Persona: "Review this code as a senior engineer focused on security vulnerabilities"
• Incremental Complexity: "Start with the simplest working version, then add error handling, then add caching"

Why Legal Prompting is Different:

Legal work demands extreme precision. A misplaced word can change the meaning of a clause. Legal prompts must specify the jurisdiction, applicable laws, document type, and the exact legal standard being applied. There is no room for creative interpretation.

Legal Prompt Framework (Indian Context):

• Jurisdiction: "Under Indian law, specifically the Indian Contract Act, 1872"
• Document Type: "Draft an NDA / Draft a Written Statement / Prepare a Legal Notice under Section 138 NI Act"
• Parties: "Between Company A (First Party) and Company B (Second Party)"
• Key Clauses: "Include non-compete (2 years, same industry), IP assignment, liquidated damages clause"
• Tone: "Formal legal language, avoid ambiguous terms like 'reasonable' without defining them"
• Compliance: "Ensure GDPR compliance for data processing clauses"

Critical Warnings for Legal AI:

• Never Final: AI-generated legal documents must ALWAYS be reviewed by a licensed lawyer
• Hallucinated Citations: LLMs frequently invent fake case law citations. Always verify every citation
• Jurisdiction Mixing: LLMs often mix US and Indian law. Be explicit about jurisdiction
• Outdated Law: LLM training data may not include recent amendments

Medical Prompting Principles:

Medical prompting must follow clinical reasoning patterns: differential diagnosis, evidence-based guidelines, and systematic documentation. The output format must match what clinicians use (SOAP notes, differential lists, treatment plans).

SOAP Note Prompt Pattern:

Given the following patient presentation, create a SOAP note:

S (Subjective): Document patient-reported symptoms
O (Objective): Document measurable findings
A (Assessment): Provide differential diagnosis ranked by probability
P (Plan): Recommend investigations and initial management

Follow Indian clinical guidelines where applicable.
Flag any red-flag symptoms that require urgent attention.
Do NOT provide a definitive diagnosis - provide differentials.

Medical vs Code vs Legal - Comparison:

Non-Negotiable Rules for Medical AI:

• Always include disclaimer: "This is not a diagnosis. Consult a qualified physician."
• Never recommend specific drug dosages without clinical review
• Always flag emergency/red-flag symptoms prominently
• Provide differential diagnosis, never a single definitive answer

Prompt Library Architecture:

Instead of crafting prompts from scratch each time, build a library of tested, versioned prompt templates for common domain tasks. Each template should include the domain context, output format, quality criteria, and example outputs.

• Base Layer: Domain persona + vocabulary + standards
• Task Layer: Specific task instructions + output format
• Context Layer: Runtime data (user input, retrieved documents)
• Quality Layer: Validation criteria + example good/bad outputs

Version Control for Prompts:

• Semantic Versioning: v1.0 (initial), v1.1 (minor fix), v2.0 (major change)
• A/B Testing: Run two prompt versions in parallel, measure which performs better
• Regression Testing: Test suite of known inputs/expected outputs to catch prompt regressions
• Changelog: Document why each change was made and what it improved

Domain Adaptation Checklist:

1. Identify the top 10 tasks in your domain that LLMs can assist with
2. For each task, document the expected output format and quality criteria
3. Create a base prompt with domain persona and vocabulary
4. Add task-specific instructions and examples
5. Test with 20+ real-world inputs and iterate
6. Add guardrails for domain-specific risks (legal disclaimers, medical warnings)
7. Version control and maintain a regression test suite

Q: Why do generic prompts fail in specialized domains?

Q: What should a good code generation prompt include?

Q: What is the biggest risk of using AI for legal document generation?

Q: How would you structure a prompt library for a team?

Q: Compare error tolerance across code, legal, and medical AI domains.