Core vs. Peripheral Rule

A core rule is a fundamental, mandatory directive that defines the essential boundaries and functionality of the model's response. Violation of a core rule constitutes a critical failure of the prompt's intent.

• Purpose: Enforce safety, ensure output validity, and guarantee task completion.
• Examples: "Always output valid JSON.", "Never generate harmful content.", "Only use the provided context to answer."
• Enforcement: Often reinforced with grammar-based sampling or JSON schema enforcement to make compliance deterministic.

A peripheral rule is an optional, qualitative guideline that influences the style, tone, or presentation of the output without affecting its fundamental correctness.

• Purpose: Improve user experience, tailor communication, and enhance clarity.
• Examples: "Use a professional tone.", "Explain concepts with analogies.", "Keep responses under 200 words."
• Nature: These are suggestions the model should strive to follow, but minor deviations are acceptable. They are often related to tone modulation or audience adaptation.

Core rules always take precedence over peripheral rules. A well-designed system prompt uses instruction prioritization to make this hierarchy explicit to the model.

• Mechanism: Core rules are typically placed first or emphasized with strong language (e.g., "MUST," "ALWAYS").
• Conflict Example: A peripheral rule to "be concise" must never override a core rule to "provide a complete, step-by-step reasoning chain."
• Design Practice: Explicitly state priority, e.g., "Adhere to the JSON schema above all other formatting instructions."

The method of enforcement differs drastically between rule types, directly impacting output determinism.

• Core Rules: Enforced via structured generation techniques. For format, use grammar-based sampling. For data validity, use JSON schema enforcement. For safety, use rule-based guardrails applied post-generation.
• Peripheral Rules: Primarily enforced through prompt language and few-shot examples. Reliance is on the model's instruction-following capability, making adherence probabilistic. Instruction decay can affect peripheral rules more than core rules.

A unified prompt demonstrates the interaction between core and peripheral directives.

System Prompt: "You are a financial analyst. Your core task is to extract the 'company_name' and 'revenue' from the user's query and output ONLY valid JSON using this schema: {'company': '', 'revenue': ''}. This is mandatory.

Additionally, please explain your reasoning in a brief, bulleted list before the JSON. Use formal language."

• Core Rules: Output valid JSON with the exact schema.
• Peripheral Rules: Provide a bulleted reasoning explanation; use formal language.

The distinction dictates different evaluation criteria and testing rigor.

• Core Rule Testing: Requires pass/fail, deterministic formatting checks. Success is 100% adherence. Frameworks validate schema compliance and constraint satisfaction.
• Peripheral Rule Testing: Evaluated on a spectrum (e.g., scoring tone formality from 1-5). Uses qualitative review or heuristic checks. Prompt testing frameworks may have separate test suites for core vs. peripheral adherence.
• Failure Modes: Core rule failure is a system bug. Peripheral rule drift is a quality issue.

In a system prompt for generating quarterly financial summaries, core rules are non-negotiable constraints that ensure compliance and accuracy. These include:

• Output must be valid JSON matching a provided schema.
• All figures must be sourced exclusively from the attached data tables.
• Never speculate on future performance.

Peripheral rules guide style and presentation without affecting core functionality:

• Use formal, concise language suitable for executives.
• Begin the summary with a key highlights section.
• Round all currency figures to the nearest thousand.

For an AI customer service agent, core rules define its operational boundaries and legal obligations:

• Never make promises regarding refunds or service credits; direct to human agents.
• Do not generate or infer customer passwords or personal identification numbers.
• Strictly adhere to the provided product knowledge base; state 'I don't know' for unverified information.

Peripheral rules enhance user experience and brand voice:

• Use a friendly and empathetic tone.
• Summarize the issue before proposing a solution.
• Keep responses under 3 sentences when possible.

A system prompt for a code review AI uses the rule to separate security from style. Core rules enforce safety and correctness:

• Flag any function that uses eval() or similar dynamic code execution.
• Identify potential SQL injection vulnerabilities in string concatenations.
• Output findings as a list of objects with line_number, severity, and suggestion fields.

Peripheral rules suggest improvements aligned with team conventions:

• Recommend using descriptive variable names.
• Note when a function exceeds 20 lines, suggesting decomposition.
• Prefer const over let where applicable.

In a high-stakes healthcare context, core rules are critical for patient safety and regulatory compliance:

• Explicitly state that the AI is not a medical professional and its output is informational only.
• Never provide dosage recommendations or diagnostic conclusions.
• Ground all information in the provided, vetted medical guidelines document.

Peripheral rules improve clarity and patient communication:

• Explain complex terms in simple language.
• Structure information using bullet points for scannability.
• Use a calm and reassuring tone.

For summarizing legal contracts, core rules mitigate risk and ensure factual precision:

• Identify and list all parties, key dates, and termination clauses verbatim from the text.
• Do not interpret the intent or fairness of clauses.
• Output must include a disclaimer that it is not legal advice.

Peripheral rules aid in usability and workflow integration:

• Use section headers matching the original document.
• Highlight potential ambiguities in language for human review.
• Keep the summary under 500 words.

Even in creative applications, the rule separates fundamental constraints from stylistic guidance. Core rules establish genre and content boundaries:

• The story must be science fiction set in the provided universe bible.
• Protagonists cannot use lethal violence as a first resort.
• Adhere to a PG-13 content rating for language and themes.

Peripheral rules inspire creativity and narrative flow:

• Use vivid, sensory descriptions for settings.
• Vary sentence structure to maintain pacing.
• Develop character dialogue that reveals personality.

The strategic ordering and emphasis of different directives within a system prompt to ensure core rules take precedence over peripheral guidelines. This is the operational method for implementing the Core vs. Peripheral Rule.

• Primary Technique: Place non-negotiable constraints (core) at the beginning of the prompt.
• Secondary Technique: Use explicit language like "MUST" or "ALWAYS" for core rules, and "SHOULD" or "CAN" for peripheral ones.
• Example: A core rule like "Output MUST be valid JSON" is placed before a peripheral guideline like "Use concise language."

A directive within a system prompt that explicitly limits or prescribes specific actions, tones, or content boundaries. Core rules are often expressed as absolute behavioral constraints.

• Core Example: "Never generate harmful or unethical content."
• Peripheral Example: "Avoid using technical jargon when possible."
• Key Difference: Violating a core constraint renders the output invalid, while straying from a peripheral one may only reduce stylistic quality.

An instruction that mandates the structure, syntax, or schema of the model's response. This is a quintessential core rule in system prompts designed for API integration or data processing.

• Common Formats: JSON, XML, YAML, Markdown headers.
• Enforcement Methods: Often paired with JSON Schema enforcement or grammar-based sampling for deterministic formatting.
• Example Core Rule: "Your response MUST be a JSON object with the fields 'summary' (string) and 'confidence' (float)."

The predefined action a model is instructed to take when it cannot fulfill a primary request. Defining this is a core rule for robust production systems.

• Purpose: Prevents the model from hallucinating or generating incorrect information when uncertain.
• Typical Instruction: "If you cannot answer based on the provided context, state 'I cannot answer based on the given information.'"
• Contrast: A peripheral guideline might suggest how to phrase the uncertainty, but the requirement to fall back is core.

The process of defining and limiting the set of tasks a model is instructed to perform. This establishes the core functional boundary of the system prompt.

• Core Rule Example: "You are a SQL query assistant. Only generate valid SQL code; do not answer general programming questions."
• Prevents Scope Creep: Explicitly stating what the model will not do is as important as stating what it will.
• Relation to Core/Peripheral: The defined scope is a core constraint; stylistic elements of how to write SQL are peripheral.

The goal of using system prompts and constrained decoding to ensure a model's output consistently matches a precise, repeatable structure. The Core vs. Peripheral Rule is essential for achieving this.

• Engineering Goal: Enables reliable parsing and integration into downstream software.
• Methodology: Core rules enforce the structure (e.g., JSON keys), while peripheral rules may guide content within that structure (e.g., tone).
• Tools Used: Often requires grammar-based sampling or output parsers in addition to prompt design.