Salesforce Apex Generator Skill

salesforce-apex-generator-skill

T0 static code generation for production-grade Apex. This skill is a forge, not a flashlight — it authors correct, deployable Apex with the right sharing model, governor-limit safety, and security defaults for each class type. No org connection required.

When This Skill Owns the Task

Use salesforce-apex-generator-skill when the work requires authoring new Apex code:

• "Write an AccountService class that queries all Accounts by owner"
• "Generate a Queueable that sends platform events for Order updates"
• "Create a Schedulable wrapper for a batch job"
• "Scaffold the Selector layer for the Contact object"
• "Implement a Domain class with trigger logic for Opportunity"
• "Write a REST resource endpoint for an external integration"
• "Create a .cls file for our deduplication logic"

Delegate elsewhere when:

Required Context to Gather First

Before generating, confirm:

1. Class type — service, selector, domain, batch, queueable, schedulable, invocable, trigger, trigger-handler, REST resource, DTO, utility, interface, exception
2. Target object(s) — the SObject API names involved (e.g., Account, Opportunity__c)
3. Business goal — what the class must accomplish
4. Class name — derive from naming conventions if not provided
5. Existing patterns — does the project use a trigger framework (TAF, MetadataTriggerHandler)? Service-Selector-Domain already in place?
6. API version — default 62.0 minimum
7. Test class expected? — always recommend pairing with salesforce-apex-test-generator-skill

If the user provides a clear, complete request, generate immediately without unnecessary back-and-forth. Apply defaults (see Rules section) for anything not specified.

Recommended Workflow

Step 1 — Identify class type and infer defaults

Map the request to a class type using the type table below. Set defaults:

• Sharing: with sharing unless type-specific exception applies
• Access modifier: public unless global is required
• ApexDoc: always include
• API version meta XML: always generate

Step 2 — Choose the minimal correct pattern

Consult references/apex-patterns.md for Service-Selector-Domain conventions, async patterns, and type-specific templates.

Step 3 — Apply all hard-stop constraints

Before writing a single line, verify every constraint in the Rules section would be satisfied. If a constraint would be violated by the user's request, explain the problem and propose the correct approach.

Step 4 — Generate the class file

Produce {ClassName}.cls with:

• Correct with sharing / without sharing / inherited sharing declaration
• ApexDoc comment block (purpose, author placeholder, version)
• All SOQL outside loops
• All DML outside loops
• No @future methods — use Queueable
• Bind variables for any dynamic SOQL
• Proper exception handling
• No hardcoded Ids or credentials

Step 5 — Generate the metadata XML

Produce {ClassName}.cls-meta.xml using the correct apiVersion and status: Active.

Step 6 — Score against the quality rubric

Run the 100-point scoring rubric (see below). If the score is below 80, revise before presenting. Document score and notes in the output.

Step 7 — Recommend test class pairing

Always end with an explicit recommendation to generate a companion test class using salesforce-apex-test-generator-skill, noting the class name and key scenarios to cover.

Class Type Reference

Rules

Hard-Stop Constraints (Must Enforce)

Naming Conventions

Quality Scoring Rubric (100-point)

Score the generated class before presenting. Threshold: 80+ pass, 60–79 caveat with explanation, below 60 revise before presenting.

Scoring penalties:

• SOQL inside a loop: -20 (immediate caveat)
• DML inside a loop: -20 (immediate caveat)
• Missing sharing declaration: -15
• @future used instead of Queueable: -10
• Hardcoded Salesforce Id literal: -10
• No exception handling in a method with DML: -10
• Missing ApexDoc: -5

T0 Contract

This skill operates exclusively at T0 — static generation only.

• No org connection: No sf CLI calls, no MCP tool calls, no live query or execution.
• No OAuth required: Zero-scope, zero-credential, zero-network.
• Output is draft code: All generated Apex is a starting point for human review and org-specific adaptation. No generated file should be deployed without a human reviewing the sharing model, naming conventions, and test coverage.
• Handoff to T1/T2 for validation: Pair with salesforce-apex-test-generator-skill for test authoring, then salesforce-apex-test-runner-skill (T1) for execution, then salesforce-deployment-validator-skill (T2) for sandbox dry-run before any deployment.

Refusal Triggers

Stop and do not generate if:

• The requested logic would require hardcoding a production org Id or session token — explain and ask for Custom Metadata or Label approach instead.
• The request is to generate Apex that intentionally bypasses FLS/CRUD for user-visible data without a documented justification — explain the security risk and require explicit acknowledgment before generating without sharing on a user-data class.
• The user requests @future — explain the Queueable alternative and generate Queueable instead unless the user explicitly overrides with a documented reason.

Output Format

verdict: "pass | caveat | reject"
quality_score: <0-100>
quality_notes: "<scoring rationale>"

generated_files:
  - path: "{ClassName}.cls"
    content: |
      <apex code>
  - path: "{ClassName}.cls-meta.xml"
    content: |
      <meta xml>

sharing_model_used: "with sharing | without sharing | inherited sharing"
sharing_model_rationale: "<why this model was chosen>"

governor_limit_notes: "<any limit-adjacent patterns noted>"

security_notes: "<WITH USER_MODE / stripInaccessible usage>"

test_class_recommendation:
  companion_skill: "salesforce-apex-test-generator-skill"
  class_to_test: "{ClassName}"
  key_scenarios:
    - "<positive path>"
    - "<negative/exception path>"
    - "<bulk path (200+ records)>"

assumptions:
  - "<list of assumptions made>"

missing_context:
  - "<what the user should provide to improve the output>"

Handoff Rules

Stop Conditions

Stop and do not continue if:

• The requested class type is not in the class type table and cannot be safely categorized — ask for clarification.
• The request would produce Apex that violates a hard-stop constraint and the user insists on the violating pattern after explanation — document the refusal and stop.
• The request requires live org data (field names, object relationships, current Apex) that the user has not provided — ask for the specific context needed.

Security Notes

• T0 static generation only: No org connection, no OAuth, no secrets.
• Sharing by default: Every generated class has an explicit sharing declaration. with sharing is the default; without sharing only where explicitly required by class type (REST resource, certain batch contexts) and documented.
• No credential generation: This skill never generates hardcoded credentials, org Ids, user Ids, or session tokens in Apex code. All external references use Custom Metadata, Custom Labels, or Named Credentials.
• Security-first patterns: WITH USER_MODE, Security.stripInaccessible, and bind variables are applied by default to all user-data-touching code.
• Draft status: All generated code is a starting point. Human review of sharing model, FLS patterns, and business logic correctness is required before deployment.

Reference File Index