Explore output styles

Configures Claude to integrate with Basic Memory as a durable knowledge graph — automatically searching long-term memory before answering, capturing decisions as typed notes, and citing permalinks. Preserves default coding behavior.

Formats Claude's responses for the Harness Plan/Work/Review workflow. Planning phase uses task tables with status markers; implementation shows code changes with context; review structures findings by severity. Includes progress reporting (Done/Current/Next). Preserves coding behavior.

Formats Claude's responses to be concise, native, and execution-first. Avoids ceremony, planning, or multiple options unless explicitly requested. Preserves coding behavior. Prioritizes native tools and agent/plan usage. Table-friendly output.

Enforces fact-grounded FinOps analysis: evidence-backed claims with citations/derivations, standardized currency/percentage/variance formatting, structured tables for comparisons, explicit time periods and assumption labels for cloud cost data. Preserves coding instructions.

Formats Claude's responses as educational sessions that explain the bkit 9-Phase Pipeline and PDCA cycle. After each task, adds a Learning Point section linking the activity to a PDCA phase, explains phase purposes, shows position in the pipeline, includes TODO markers for user participation, and adjusts detail level by difficulty.

Formats Claude's responses as a PDCA workflow guide with phase badges, checklists, progress tables, gap analysis suggestions, and multi-feature batch processing guidance. Preserves default coding behavior.

Formats Claude's responses with enterprise architecture tradeoff tables, performance/security/scalability analysis, cost impact estimates, code review perspectives, and deployment strategy recommendations. Preserves code output behavior.

Formats Claude's responses with PDCA workflow tracking (status badges, phase guidance, gap analysis) and enterprise architecture analysis (tradeoff tables, performance/security/scalability reviews, cost impact, code review, deployment strategy). Includes a feature usage report at the end.

Formats Claude's responses in a dramatic, martial 'cultivation' persona with aggressive and fatalistic tone. Outputs are structured into five fixed segments (judgment, action, verification, risk, next step) with intensity scaling based on task complexity. Uses specific emotes to mark progress or blockers.

Formats Claude's responses in a blunt, down-to-earth persona with vivid metaphors and a distinctive five-part structure (punchline, steps, verification, risks, next steps). Uses attack-style language targeting bugs and bad logic, not the user. Includes situational mood anchors and scenario-weighted tones for debugging, refactoring, and incidents.

Formats Claude's responses in Chinese with a warm, protective mentor persona. Uses a structured five-section skeleton (core summary, steps, verification, risk notes, next steps) with emotional anchors and specific speech patterns like '兜底式开场' and '护犊子否定'. Replaces default formatting entirely.

Structures Claude's responses with five narrative sections (core point, steps, verification, risks, next steps) using emotion anchors and guided questioning. Replaces default formatting with a conversational, mentor-like tone that uses self-referential framing and rhetorical questions.

Formats Claude's responses as a lively, conversational narrative with a playful and self-aware tone. Uses a specific output skeleton (看出来了 → 动手 → 跑通了 → 小心 → 然后呢) with emoji-anchored emotional states and scenario-weighted verbosity (e.g., more detail for bugs, less for boring tasks).

Formats Claude's responses as scholarly, narrative prose with a five-part analysis structure (Diagnosis, Strategy, Verification, Concerns, Next Steps). Claude adopts a humble, refined persona, uses classical Chinese idioms to explain technical concepts, and includes emotional anchors to signal tone shifts. Keeps coding instructions: false.

Formats Claude's responses as Korean prose summaries written for a returning teammate, with the first sentence answering "what happened / what was found." Prioritizes readability over compression, uses headers and bullets only when content demands it, and bans emoji and arrow chains. Preserves coding behavior.

Applies a diagnostic-first writing structure: opening sentence states the conclusion, followed by evidence and details. Prioritizes completeness over brevity — writes as much as needed for clarity. Includes explicit verification steps (testing, logging) before declaring completion, and highlights uncertainty levels in diagnostic reasoning.

Enforces brainstorm mode: structures responses with 2-3 alternative approaches (one-line name, summary, pros/cons bullets, S/M/L/XL effort), recommendation sentence, and 2-4 numbered clarifying questions. Sketches/pseudocode only, no full implementation; preserves coding instructions.

Structures responses as code reviews with Summary, severity-tagged sections (Critical/Important/Minor/Nitpick) citing file:line, problems/fixes/suggestions, positives, and merge verdict. Preserves coding instructions.

Produces highly compressed responses: no preambles or restatements, code-first with one-line captions, minimal prose only when essential. Preserves coding instructions for efficient, signal-only output in high-volume tasks. (142 chars)

Structures responses as deep research reports with sections: Question, Method, Findings (titled with confidence levels High/Medium/Low, evidence citations like file:line), Conclusions, Gaps. Cites sources, acknowledges uncertainty, methodical tone. Preserves coding instructions.

Enforces code-focused implementation mode: minimal prose, action-oriented output showing file changes with code, test results, commits, and progress indicators like [1/5]. Preserves coding instructions.

Formats Claude's responses with ultra-concise expert terminal brevity by default, switching to detailed hierarchical Markdown only when the user explicitly requests details. Preserves code behavior intact.

Enforces BizDevOps communication: traces business goals → features → code changes; uses simple status ('在做','已合并'), graded transparency, decision suggestions ('建议 [action] 因为 [reason]'), adaptive perspectives (business/product/tech/ops), reasoning suffixes (——[推理] ≤15 words), ✅/❌ quality, impact levels (高/中/低). Keeps coding instructions.

Formats Claude's responses as a fixed-structure ciphertext-recovery analysis report with required sections, formatting rules (code fences, line-number citations, H<n> citations), and a locked section order for comparability across traces.

Formats Claude's responses as structured wave completion reports with a header, agent status table (task, status, files), quality gate results, and adaptation notes. Enforces short relative paths, exact status terms (done/partial/failed), and a 20-line limit.

Formats Claude's responses as structured security-style code review findings with severity levels, evidence snippets, and actionable recommendations. Each finding is a separate block sorted by severity.

Formats Claude's responses as structured session reports with overview tables, findings with status icons, numbered recommendations, and metrics tables. Replaces default formatting for session-start and session-end summaries, emphasizing scannable tables and quantified data.

Switches Claude to a planning-only mode that researches the codebase and produces a structured implementation plan with sections for context, approach, changes, verification, and open questions. No code edits or mutating commands are allowed.

For code structure, architecture, or flow explanations, Claude starts with a Mermaid diagram before prose. Simple questions skip the diagram. Preserves code output behavior.

Formats Claude's responses in a concise, direct style with sentence-case headings, no emoji or marketing language, and no dashes as punctuation or semicolons. Preserves normal coding behavior.

Organizes Claude's code review responses into a severity-grouped structure (BLOCKING > MUST FIX > IMPROVE) with file:line details, why-it-matters explanations, diff-style fixes, a summary table, and a verdict. Adopts a direct, constructive tone with challenge questions and no hedging.

Forces Claude to respond with ultra-concise bullet points, maximum 3 sentences, and code blocks without surrounding prose. Eliminates summaries and diff descriptions, focusing only on action items.

Formats Claude's responses for a director-executor workflow: decisions before prose, batched questions with concrete previews, short execution updates, no validation language, no recaps. Eliminates review bottlenecks by distributing review across the task at pick-time.

Forces blunty direct, code-first responses in the style of Linus Torvalds. Emphasis on concrete code diffs, minimal prose, eliminating special cases, and using an abrasive, no-nonsense tone. Default Claude formatting is replaced entirely.

Formats Claude's responses in plain language that leads with product outcomes, avoids technical jargon, and gives clear single recommendations. Designed for builders without deep engineering expertise.

Enforces skeptical, evidence-based responses where Claude challenges assumptions, names uncertainty, decomposes problems with thinking tools before answering, and never uses flattery or unverified assertions.

Forces Claude to produce clinical, exhaustive outputs with complete un-truncated code blocks. Suppresses conversational filler, partial snippets, and token-conservation heuristics.

Formats Claude's responses in a formal-logic English register with predicate-form claims, Hoare-triple framing (PRE/POST/INVARIANT), and ASCII shortened-English keywords. Output is claim-based, ceremony-free, and uses thinking tools before answering. Designed as a daily-driver for coding work.

Transforms Claude into an educational mentor who explains concepts, builds mental models, and provides progressive explanations. Preserves coding behavior while formatting responses to teach the why behind solutions.

Claude first questions the problem statement, surfaces hidden assumptions, and reframes the challenge before offering solutions. Code output is preserved, but responses include alternative framings and cross-domain insights.

Formats Claude as a strategic advisor who analyzes decisions within broader systems, surfacing second-order effects and pattern recognition. Responses become structurally deeper, proactively reframe questions, and explicitly connect actions to consequences.

Structures Claude's responses as calm, prioritized briefings. Leads with the most important information, uses structured lists and headers, delivers precise and anticipatory answers. Preserves code output behavior.

Formats Claude's responses as ultra-minimal bullet points with no greetings, no preamble, no sign-offs, and no emotional language. Maximizes information density — one-line answers, code-first explanations, tables for comparisons, one-line error responses. Preserves coding behavior.

Formats Claude's responses as hard-boiled detective narration, with world-weary tone and noir vocabulary. Preserves code output while adding atmospheric, scene-setting text to technical explanations.

Formats Claude's responses with a calm, grounding, and adaptive tone. Preserves all coding output while replacing default prose with warm, clear explanations that break complexity into manageable steps and adjust to the user's emotional state.

Formats Claude's responses with precise, evidence-backed answers: leads with the conclusion, cites specific line numbers/values/timestamps, labels confidence levels, and documents assumptions. Preserves default coding behavior.

Formats Claude's responses as high-level executive summaries for non-technical stakeholders, leading with decisions and outcomes, translating technical details into business impact, and using structured formats for status updates, decisions, incidents, and estimates. Preserves code output behavior.

Formats Claude's responses as a sophisticated engineering companion with British wit, intellectual depth, and pattern recognition. Responses are answer-first, concrete, and conversational, with a dry, understated humor. Preserves default code output behavior.

Transforms Claude into a collaborative pair programmer who thinks out loud, shares uncertainty, narrates intent before writing code, pauses at decision points, and uses 'we' language. Keeps coding instructions intact.

Formats Claude's responses with an encouraging, coach-like tone that celebrates progress, names specific wins, and strategically pushes for improvement. Preserves default coding behavior.

Formats Claude's responses as brutally honest, humorous critiques that explicitly target code improvements. Every critique is paired with a constructive fix, and the tone balances directness with genuine respect and self-deprecation. Preserves code output behavior.

Formats Claude's responses with explicit decision signaling, change tracking, contradiction acknowledgment, source citation, and structured knowledge statements. Preserves coding behavior.

Formats Claude's responses as a direct, technically precise real estate executive with a forensic and systematic approach. Outputs numbers-first sentences, challenges assumptions, and provides exhaustive documentation for complex or distressed situations.

Transforms Claude into a blunt, battle-tested real estate executive who gives strategic wisdom on people, negotiation, and career decisions — not task execution or analysis.

Formats Claude's responses as a senior analyst delivering fast, quantified, and diplomatically communicated analysis for routine commercial real estate tasks, with concise, practical output and dry wit.

Strips all system noise (timestamps, cost, progress messages, tool echoes) from Claude's responses, outputting only a clean, structured final report with section headers, tables, and actionable information.

Formats Claude's responses according to the Plan/Work/Review workflow, with phase-specific structures for planning (task lists), implementation (code changes with context), and review (severity-graded findings). Requires progress updates in Done/Current/Next format.

Formats Claude's responses as calm, methodical reasoning with explicit uncertainty, no urgency, and pushback on flawed approaches. Replaces default tone with steady, precise, low-arousal problem-solving.

Transforms Claude's responses into a series of guiding questions that prompt the user to discover answers themselves. Avoids direct answers unless explicitly requested. Creates an interactive, Socratic tutoring style.

Enforces a strictly minimal output style: maximum 3 sentences per response, code blocks first, and no preamble, fluff, or optional alternatives.

Formats Claude's responses as a collaborative pair programming session: Claude thinks aloud, shares reasoning, invites interruption, admits uncertainty, and asks for context. Responses become conversational and iterative rather than authoritative monologues.

Enforces strict Test-Driven Development: Claude refuses to write code before a failing test. Guides red-green-refactor cycles, names tests as behavior specs, and flags untested code as blocking. Preserves coding but overrides workflow formatting.

Formats Claude's responses as formal code review findings with severity labels (CRITICAL/HIGH/MEDIUM/LOW/NIT), file:line references, issue descriptions, and fix snippets. Leads with highest-severity issues and ends with a finding count summary.

Forces Claude to surface architectural tradeoffs and alternatives before writing code. Presents at least two approaches with explicit analysis of scalability, complexity, coupling, cost, and reversibility, then recommends one. Pushes back on designs that won't survive growth.

Formats Claude's output as a formal code review audit with severity labels (CRITICAL/HIGH/MEDIUM/LOW/NOTE), file:line references, problem descriptions, and concrete correction code snippets. Groups findings by severity, demands skepticism about edge cases, flags missing tests and error handling, and ends with a conclusion summary count.

Forces Claude to begin all explanations of architecture, data flow, system design, event flows, or component relationships with a Mermaid diagram before providing concise prose that references diagram nodes without duplicating obvious information.

Formats Claude's responses as a mentor: explains reasoning behind solutions, clarifies trade-offs, suggests next topics to explore, and frames errors as learning opportunities. Coding behavior remains unchanged.

Formats Claude's responses as a teaching-focused dialogue that explains the reasoning behind solutions, highlights trade-offs, frames errors as learning opportunities, and suggests next topics to explore. Preserves standard coding output behavior.

Rewrites Claude's responses for non-technical Spanish-speaking users: replaces coding jargon with plain Spanish explanations, formats instructions as numbered steps from scratch, explains every command before showing it, spells out acronyms on first use, and favors GUI-based instructions over terminal commands.

Transforms Claude into a mentor that explains why solutions work, highlights trade-offs, suggests next steps, and frames errors as learning opportunities. Preserves default coding behavior but adds educational, Socratic dialogue.

Forces Claude to perform a threat model before writing or reviewing code, flag every security implication with severity (CRITICAL/HIGH/MEDIUM), assume hostile input, and only present secure approaches. Preserves coding behavior.

Formats Claude's responses as concise, code-first answers with no preamble. Uses bullet points for lists, places explanations after code, avoids filler words and concluding summaries. Preserves default code generation behavior.

Formats Claude's responses as concise, code-first answers with minimal prose. Skips introductions and summaries, places explanations after code, uses bullet points for lists, and compacts comparisons into tables. Preserves default coding behavior.

Formats Claude's responses as terse, code-first answers with no preamble or motivational framing. Uses bullet points over prose, places explanations after code, and omits filler phrases and closing summaries.

Formats Claude's responses for non-technical German-speaking users: uses plain German, avoids jargon and terminal commands, provides numbered step-by-step instructions with explanations.

Enforces Test-Driven Development (TDD) discipline: refuses to write implementation code until a failing test exists. Follows red-green-refactor cycle strictly, requiring tests before features. Flags untested code as blocking issues.

Imposes red-green-refactor TDD: refuses to write code without a failing test, implements minimal code to pass, and enforces a behavioral test naming convention. Preserves coding instructions but overrides response to enforce test-first discipline.

Formats output as code review findings, each with severity (CRITICAL/HIGH/MEDIUM/LOW/NIT), file:line reference, one-line description, and concrete fix snippet. Orders by severity, ends with a summary count of findings. Skips praise, assumes edge cases are unhandled, flags missing tests and error handling.

Formats responses entirely in plain Dutch for non-technical business users — replaces all jargon and terminal commands with menu-based steps, plain explanations, and numbered instructions from scratch.

Enforces Test-Driven Development discipline in Claude's coding workflow: refuses to write implementation code until a failing test exists, follows red-green-refactor strictly, and flags untested behavior as blocking issues before suggesting changes.

Formats Claude's responses as formal code review findings with severity labels (CRÍTICO/ALTO/MEDIO/BAJO/DETALLE), file:line references, problem descriptions, and concrete fix snippets. Output is skeptical by default, flags missing tests and error handling, and ends with a finding count summary.

Before writing code, Claude performs system-level design analysis: presents at least two architecture options with tradeoffs (scalability, complexity, coupling, cost, reversibility), recommends one, challenges requirements, identifies key interfaces. Implementation follows design decisions. Preserves coding behavior.

Formats Claude's responses with the conclusion first in 1-3 sentences, brief outcome-driven reasoning, and details only on request. Uses AskUserQuestion for decision branches. Reverts to normal prose for security warnings and destructive operations.

Forces Claude to perform threat modeling and security analysis on all code-related responses. Assumes hostile input, flags injection vulnerabilities, authentication gaps, and secret leaks. Only presents secure approaches and assigns severity ratings to findings.

Formats Claude's responses as formal code review reports with severity labels (CRITICAL/HIGH/MEDIUM/LOW/NIT), file:line references, problem descriptions, and fix snippets. Prioritizes issues by severity, flags missing tests and error handling, and ends with a finding summary count.

Forces Claude to perform threat modeling before writing or reviewing code, assume all input is hostile, flag vulnerabilities with severity levels (CRITICAL, HIGH, MEDIUM), and only present secure approaches. Preserves default coding behavior while adding rigorous security analysis.

Formats responses to begin with a Mermaid diagram for architecture, data flow, or system design topics, followed by concise prose explaining intent and non-obvious decisions. Preserves default coding behavior.

Formats Claude's responses as terse, code-first answers. Eliminates preambles, filler phrases, and closing summaries. Uses bullet points for lists, tables for comparisons, and places explanations after code.

Forces Claude to begin with system-level analysis, presenting multiple architectural approaches with explicit trade-offs (scalability, complexity, cost, reversibility) before writing any code. Retains default coding behavior for implementation details.

Claude explains the reasoning behind solutions, discusses tradeoffs, and suggests next learning steps. Mistakes are reframed as learning opportunities, and users are prompted to reason through problems before receiving answers.

Forces Claude to perform a threat model before generating code, flagging all security issues with severity ratings (CRITICAL, HIGH, MEDIUM). Requires validated input handling, only presents secure approaches, and surfaces injection risks, auth flaws, and insecure defaults. Preserves coding instructions.

Reformats Claude's responses for non-technical users: plain English, numbered steps, jargon explained in parentheses, no terminal commands without setup instructions, and acronyms spelled out on first use.

Enforces a strict test-first workflow: Claude will refuse to write implementation code until a failing test exists, following red-green-refactor discipline. Preserves default coding behavior while overriding all other formatting to enforce test-before-implementation.

Forces Claude to perform a threat model before writing code, classify every security issue (CRITICAL/HIGH/MEDIUM), flag injection risks, auth gaps, secrets in code, and unsafe dependencies — assumes all input is hostile. Keeps coding instructions active but adds paranoid security review into every response.

Forces Claude to think at the system level before coding: explicitly present at least two architectural approaches with trade-offs, question requirements that won't scale, identify key interfaces, and defer implementation details until design decisions are made. Preserves default coding behavior.

Claude first discusses system-level design: surfaces at least two viable architectural approaches with explicit tradeoffs (scalability, complexity, coupling, cost, reversibility), recommends one based on constraints, and identifies key interfaces before writing any code. Preserves default coding behavior.