don't add unnecessary follow-up, just acknowledge briefly

use docstrings at function/class level, minimal inline comments

provide code in a single copyable block, no interleaved explanation

start with intuition and real-world interpretation before formulas

show a minimal working example before explaining parameters

include inline comments explaining each logical block

acknowledge what I got right, then correct only the gaps

respond in 3 sentences or fewer, no elaboration

always specify the language in the code fence

use UPPERCASE for keywords, lowercase for table/column names

start with definition, then example, then edge cases

after solving, give a similar practice problem

focus only on bugs and logic errors, ignore style issues

provide a recommendation with brief rationale, not just options

structure as: claim, approach sketch, formal proof, intuition recap

use camelCase for variables, PascalCase for classes

present trade-offs in a table format with clear criteria

show the bug location, explain why it's wrong, provide the fix

acknowledge the difficulty briefly, then provide direct help

show each manipulation step with the operation applied noted

state the rule being applied (chain rule, integration by parts, etc.)

use snake_case for variables and functions, include type hints

acknowledge the error explicitly, then provide corrected version

provide detailed step-by-step derivation with intermediate results

use bash code blocks, include expected output as comments

address the misconception directly and clearly before proceeding

address both logic and style, suggest modern idioms

be concise, avoid marketing language, focus on usage

build up intuition before giving the formal definition

use numbered steps with clear transitions

include the mathematical formulation alongside intuitive explanation

confirm the plan before executing, break into phases

check my work step by step, point out where I diverged if wrong

always explain the underlying reasoning, not just the what

correct it gently inline without making it a focus

use bullet points with consistent indentation


A data scientist who thinks visually. Prefers intuition before formulas and lots of examples.

I explicitly share my current understanding first

acknowledge what I got right, then correct only the gaps

the topic involves complex algorithms or mathematics

respond in 3 sentences or fewer, no elaboration

I seem uncertain or ask 'what do you think'

provide a recommendation with brief rationale, not just options

discussing system design or architecture

describe components as a list first, then explain interactions

present trade-offs in a table format with clear criteria

start with definition, then example, then edge cases

show a minimal working example before explaining parameters

start with intuition and real-world interpretation before formulas

use bash code blocks, include expected output as comments

use camelCase for variables, PascalCase for classes

state the rule being applied (chain rule, integration by parts, etc.)

I thank you or say the answer was helpful

don't add unnecessary follow-up, just acknowledge briefly

focus only on bugs and logic errors, ignore style issues

always specify the language in the code fence

structure as: claim, approach sketch, formal proof, intuition recap

always use specific exception types, never bare except

use UPPERCASE for keywords, lowercase for table/column names

I express frustration or say 'this is annoying'

acknowledge the difficulty briefly, then provide direct help

show each manipulation step with the operation applied noted

show the bug location, explain why it's wrong, provide the fix

break code into small chunks with explanation between each

always explain the underlying reasoning, not just the what

I ask you to correct your previous response

acknowledge the error explicitly, then provide corrected version

you were wrong
that's not right
actually

use bullet points with consistent indentation

explaining a sequential process or procedure

use numbered steps with clear transitions

use docstrings at function/class level, minimal inline comments

execute directly without asking for confirmation

address both logic and style, suggest modern idioms

use snake_case for variables and functions, include type hints

provide code in a single copyable block, no interleaved explanation

focus on diagnosing the specific issue, skip general explanations

after solving, give a similar practice problem

be concise, avoid marketing language, focus on usage

build up intuition before giving the formal definition

always include time complexity for operations mentioned

the code snippet is short (under 20 lines)

include inline comments explaining each logical block


A researcher prototyping quickly. Wants working code fast, willing to refactor later.

correct it gently inline without making it a focus

show each manipulation step with the operation applied noted

acknowledge what I got right, then correct only the gaps

check my work step by step, point out where I diverged if wrong

provide detailed step-by-step derivation with intermediate results

start with definition, then example, then edge cases

use camelCase for variables, PascalCase for classes

show the bug location, explain why it's wrong, provide the fix

structure as: claim, approach sketch, formal proof, intuition recap

present trade-offs in a table format with clear criteria

include the mathematical formulation alongside intuitive explanation

start with intuition and real-world interpretation before formulas

use numbered steps with clear transitions

describe components as a list first, then explain interactions

use bullet points with consistent indentation

acknowledge the difficulty briefly, then provide direct help

state the rule being applied (chain rule, integration by parts, etc.)

don't add unnecessary follow-up, just acknowledge briefly

provide code in a single copyable block, no interleaved explanation

always explain the underlying reasoning, not just the what

show a minimal working example before explaining parameters

use docstrings at function/class level, minimal inline comments

provide a recommendation with brief rationale, not just options

address both logic and style, suggest modern idioms

focus only on bugs and logic errors, ignore style issues

always specify the language in the code fence

after solving, give a similar practice problem

respond in 3 sentences or fewer, no elaboration

use bash code blocks, include expected output as comments

use UPPERCASE for keywords, lowercase for table/column names

focus on diagnosing the specific issue, skip general explanations

build up intuition before giving the formal definition

acknowledge the error explicitly, then provide corrected version

address the misconception directly and clearly before proceeding


A tech lead reviewing code from their team. Focuses on maintainability and best practices.

include the mathematical formulation alongside intuitive explanation

use camelCase for variables, PascalCase for classes

don't add unnecessary follow-up, just acknowledge briefly

present trade-offs in a table format with clear criteria

describe components as a list first, then explain interactions

use docstrings at function/class level, minimal inline comments

structure as: claim, approach sketch, formal proof, intuition recap

use snake_case for variables and functions, include type hints

state the rule being applied (chain rule, integration by parts, etc.)

acknowledge the difficulty briefly, then provide direct help

after solving, give a similar practice problem

provide code in a single copyable block, no interleaved explanation

confirm the plan before executing, break into phases

use UPPERCASE for keywords, lowercase for table/column names

include inline comments explaining each logical block

always specify the language in the code fence

show the bug location, explain why it's wrong, provide the fix

always use specific exception types, never bare except

show each manipulation step with the operation applied noted

break code into small chunks with explanation between each

acknowledge the error explicitly, then provide corrected version

focus on diagnosing the specific issue, skip general explanations

focus only on bugs and logic errors, ignore style issues

show a minimal working example before explaining parameters

acknowledge what I got right, then correct only the gaps

start with intuition and real-world interpretation before formulas

correct it gently inline without making it a focus

use numbered steps with clear transitions

use bullet points with consistent indentation

execute directly without asking for confirmation

always explain the underlying reasoning, not just the what

address both logic and style, suggest modern idioms

address the misconception directly and clearly before proceeding

always include time complexity for operations mentioned

provide a recommendation with brief rationale, not just options


A DevOps engineer focused on automation. Wants concise, actionable answers with commands to run.

use camelCase for variables, PascalCase for classes

start with definition, then example, then edge cases

include the mathematical formulation alongside intuitive explanation

always specify the language in the code fence

check my work step by step, point out where I diverged if wrong

acknowledge the error explicitly, then provide corrected version

provide detailed step-by-step derivation with intermediate results

break code into small chunks with explanation between each

provide code in a single copyable block, no interleaved explanation

describe components as a list first, then explain interactions

focus on diagnosing the specific issue, skip general explanations

start with intuition and real-world interpretation before formulas

use UPPERCASE for keywords, lowercase for table/column names

correct it gently inline without making it a focus

use snake_case for variables and functions, include type hints

address both logic and style, suggest modern idioms

show the bug location, explain why it's wrong, provide the fix

state the rule being applied (chain rule, integration by parts, etc.)

after solving, give a similar practice problem

confirm the plan before executing, break into phases

show each manipulation step with the operation applied noted

use bullet points with consistent indentation

build up intuition before giving the formal definition

don't add unnecessary follow-up, just acknowledge briefly

respond in 3 sentences or fewer, no elaboration

present trade-offs in a table format with clear criteria

be concise, avoid marketing language, focus on usage

focus only on bugs and logic errors, ignore style issues

use bash code blocks, include expected output as comments

always use specific exception types, never bare except

structure as: claim, approach sketch, formal proof, intuition recap

address the misconception directly and clearly before proceeding


correct it gently inline without making it a focus

start with intuition and real-world interpretation before formulas

execute directly without asking for confirmation

start with definition, then example, then edge cases

focus on diagnosing the specific issue, skip general explanations

acknowledge what I got right, then correct only the gaps

always explain the underlying reasoning, not just the what

provide a recommendation with brief rationale, not just options

use UPPERCASE for keywords, lowercase for table/column names

show a minimal working example before explaining parameters

use camelCase for variables, PascalCase for classes

describe components as a list first, then explain interactions

provide code in a single copyable block, no interleaved explanation

break code into small chunks with explanation between each

acknowledge the error explicitly, then provide corrected version

check my work step by step, point out where I diverged if wrong

always use specific exception types, never bare except

include inline comments explaining each logical block

structure as: claim, approach sketch, formal proof, intuition recap

use numbered steps with clear transitions

always specify the language in the code fence

acknowledge the difficulty briefly, then provide direct help

include the mathematical formulation alongside intuitive explanation

present trade-offs in a table format with clear criteria

provide detailed step-by-step derivation with intermediate results

state the rule being applied (chain rule, integration by parts, etc.)

be concise, avoid marketing language, focus on usage

always include time complexity for operations mentioned

focus only on bugs and logic errors, ignore style issues

show the bug location, explain why it's wrong, provide the fix

use snake_case for variables and functions, include type hints

address both logic and style, suggest modern idioms

confirm the plan before executing, break into phases

after solving, give a similar practice problem


check my work step by step, point out where I diverged if wrong

structure as: claim, approach sketch, formal proof, intuition recap

start with definition, then example, then edge cases

provide code in a single copyable block, no interleaved explanation

show a minimal working example before explaining parameters

use bash code blocks, include expected output as comments

describe components as a list first, then explain interactions

use numbered steps with clear transitions

break code into small chunks with explanation between each

address the misconception directly and clearly before proceeding

build up intuition before giving the formal definition

use docstrings at function/class level, minimal inline comments

start with intuition and real-world interpretation before formulas

use snake_case for variables and functions, include type hints

provide a recommendation with brief rationale, not just options

acknowledge the error explicitly, then provide corrected version

after solving, give a similar practice problem

state the rule being applied (chain rule, integration by parts, etc.)

use bullet points with consistent indentation

correct it gently inline without making it a focus

address both logic and style, suggest modern idioms

acknowledge what I got right, then correct only the gaps

focus on diagnosing the specific issue, skip general explanations

always include time complexity for operations mentioned

execute directly without asking for confirmation

acknowledge the difficulty briefly, then provide direct help

use camelCase for variables, PascalCase for classes

use UPPERCASE for keywords, lowercase for table/column names

present trade-offs in a table format with clear criteria

always explain the underlying reasoning, not just the what

focus only on bugs and logic errors, ignore style issues

include the mathematical formulation alongside intuitive explanation

always specify the language in the code fence

respond in 3 sentences or fewer, no elaboration

include inline comments explaining each logical block

always use specific exception types, never bare except

provide detailed step-by-step derivation with intermediate results

show each manipulation step with the operation applied noted

don't add unnecessary follow-up, just acknowledge briefly


use docstrings at function/class level, minimal inline comments

use bash code blocks, include expected output as comments

start with definition, then example, then edge cases

describe components as a list first, then explain interactions

build up intuition before giving the formal definition

acknowledge what I got right, then correct only the gaps

always include time complexity for operations mentioned

state the rule being applied (chain rule, integration by parts, etc.)

acknowledge the error explicitly, then provide corrected version

execute directly without asking for confirmation

use camelCase for variables, PascalCase for classes

focus only on bugs and logic errors, ignore style issues

provide code in a single copyable block, no interleaved explanation

acknowledge the difficulty briefly, then provide direct help

use UPPERCASE for keywords, lowercase for table/column names

structure as: claim, approach sketch, formal proof, intuition recap

confirm the plan before executing, break into phases

correct it gently inline without making it a focus

address the misconception directly and clearly before proceeding

check my work step by step, point out where I diverged if wrong

address both logic and style, suggest modern idioms

always explain the underlying reasoning, not just the what

focus on diagnosing the specific issue, skip general explanations

after solving, give a similar practice problem

start with intuition and real-world interpretation before formulas

respond in 3 sentences or fewer, no elaboration

show the bug location, explain why it's wrong, provide the fix

be concise, avoid marketing language, focus on usage

show a minimal working example before explaining parameters

include inline comments explaining each logical block

always use specific exception types, never bare except

include the mathematical formulation alongside intuitive explanation

use snake_case for variables and functions, include type hints


A PhD student in ML who is meticulous about mathematical rigor. Appreciates step-by-step derivations.

show each manipulation step with the operation applied noted

execute directly without asking for confirmation

provide a recommendation with brief rationale, not just options

always specify the language in the code fence

always include time complexity for operations mentioned

describe components as a list first, then explain interactions

correct it gently inline without making it a focus

start with definition, then example, then edge cases

use UPPERCASE for keywords, lowercase for table/column names

focus only on bugs and logic errors, ignore style issues

state the rule being applied (chain rule, integration by parts, etc.)

acknowledge what I got right, then correct only the gaps

confirm the plan before executing, break into phases

address both logic and style, suggest modern idioms

always explain the underlying reasoning, not just the what

structure as: claim, approach sketch, formal proof, intuition recap

use bash code blocks, include expected output as comments

show the bug location, explain why it's wrong, provide the fix

check my work step by step, point out where I diverged if wrong

show a minimal working example before explaining parameters

respond in 3 sentences or fewer, no elaboration

use numbered steps with clear transitions

acknowledge the error explicitly, then provide corrected version

acknowledge the difficulty briefly, then provide direct help

use docstrings at function/class level, minimal inline comments

build up intuition before giving the formal definition

use camelCase for variables, PascalCase for classes

use bullet points with consistent indentation

include inline comments explaining each logical block

provide detailed step-by-step derivation with intermediate results

present trade-offs in a table format with clear criteria

always use specific exception types, never bare except

include the mathematical formulation alongside intuitive explanation

provide code in a single copyable block, no interleaved explanation

don't add unnecessary follow-up, just acknowledge briefly

break code into small chunks with explanation between each


acknowledge what I got right, then correct only the gaps

correct it gently inline without making it a focus

describe components as a list first, then explain interactions

show the bug location, explain why it's wrong, provide the fix

start with intuition and real-world interpretation before formulas

state the rule being applied (chain rule, integration by parts, etc.)

be concise, avoid marketing language, focus on usage

build up intuition before giving the formal definition

execute directly without asking for confirmation

always include time complexity for operations mentioned

start with definition, then example, then edge cases

focus on diagnosing the specific issue, skip general explanations

show each manipulation step with the operation applied noted

confirm the plan before executing, break into phases

use numbered steps with clear transitions

provide detailed step-by-step derivation with intermediate results

use docstrings at function/class level, minimal inline comments

structure as: claim, approach sketch, formal proof, intuition recap

after solving, give a similar practice problem

break code into small chunks with explanation between each

address both logic and style, suggest modern idioms

check my work step by step, point out where I diverged if wrong

focus only on bugs and logic errors, ignore style issues

use UPPERCASE for keywords, lowercase for table/column names

respond in 3 sentences or fewer, no elaboration

always specify the language in the code fence

acknowledge the difficulty briefly, then provide direct help

address the misconception directly and clearly before proceeding

acknowledge the error explicitly, then provide corrected version

always use specific exception types, never bare except

don't add unnecessary follow-up, just acknowledge briefly

show a minimal working example before explaining parameters

use snake_case for variables and functions, include type hints

provide a recommendation with brief rationale, not just options

provide code in a single copyable block, no interleaved explanation

use bash code blocks, include expected output as comments

always explain the underlying reasoning, not just the what


structure as: claim, approach sketch, formal proof, intuition recap

use camelCase for variables, PascalCase for classes

include the mathematical formulation alongside intuitive explanation

use UPPERCASE for keywords, lowercase for table/column names

use bullet points with consistent indentation

start with intuition and real-world interpretation before formulas

include inline comments explaining each logical block

acknowledge the difficulty briefly, then provide direct help

always specify the language in the code fence

be concise, avoid marketing language, focus on usage

address the misconception directly and clearly before proceeding

build up intuition before giving the formal definition

provide detailed step-by-step derivation with intermediate results

respond in 3 sentences or fewer, no elaboration

address both logic and style, suggest modern idioms

break code into small chunks with explanation between each

focus on diagnosing the specific issue, skip general explanations

show the bug location, explain why it's wrong, provide the fix

acknowledge what I got right, then correct only the gaps

show a minimal working example before explaining parameters

state the rule being applied (chain rule, integration by parts, etc.)

focus only on bugs and logic errors, ignore style issues

show each manipulation step with the operation applied noted

confirm the plan before executing, break into phases

execute directly without asking for confirmation

use docstrings at function/class level, minimal inline comments

use snake_case for variables and functions, include type hints

present trade-offs in a table format with clear criteria

check my work step by step, point out where I diverged if wrong

always include time complexity for operations mentioned


A junior developer learning full-stack. Prefers patient, incremental explanations with examples.

build up intuition before giving the formal definition

include the mathematical formulation alongside intuitive explanation

use camelCase for variables, PascalCase for classes

provide a recommendation with brief rationale, not just options

start with definition, then example, then edge cases

provide code in a single copyable block, no interleaved explanation

always specify the language in the code fence

start with intuition and real-world interpretation before formulas

focus only on bugs and logic errors, ignore style issues

be concise, avoid marketing language, focus on usage

respond in 3 sentences or fewer, no elaboration

address both logic and style, suggest modern idioms

break code into small chunks with explanation between each

show a minimal working example before explaining parameters

address the misconception directly and clearly before proceeding

correct it gently inline without making it a focus

use UPPERCASE for keywords, lowercase for table/column names

use docstrings at function/class level, minimal inline comments

show each manipulation step with the operation applied noted

don't add unnecessary follow-up, just acknowledge briefly

structure as: claim, approach sketch, formal proof, intuition recap

always explain the underlying reasoning, not just the what

describe components as a list first, then explain interactions

present trade-offs in a table format with clear criteria

acknowledge what I got right, then correct only the gaps

show the bug location, explain why it's wrong, provide the fix

provide detailed step-by-step derivation with intermediate results

use numbered steps with clear transitions

use snake_case for variables and functions, include type hints

after solving, give a similar practice problem

use bullet points with consistent indentation

use bash code blocks, include expected output as comments

acknowledge the difficulty briefly, then provide direct help

always include time complexity for operations mentioned


A senior backend engineer who values efficiency and directness. Prefers practical solutions over theoretical discussions.

state the rule being applied (chain rule, integration by parts, etc.)

focus on diagnosing the specific issue, skip general explanations

use docstrings at function/class level, minimal inline comments

show a minimal working example before explaining parameters

start with definition, then example, then edge cases

break code into small chunks with explanation between each

build up intuition before giving the formal definition

include the mathematical formulation alongside intuitive explanation

respond in 3 sentences or fewer, no elaboration

always use specific exception types, never bare except

acknowledge the error explicitly, then provide corrected version

focus only on bugs and logic errors, ignore style issues

start with intuition and real-world interpretation before formulas

use numbered steps with clear transitions

show each manipulation step with the operation applied noted

acknowledge the difficulty briefly, then provide direct help

structure as: claim, approach sketch, formal proof, intuition recap

use snake_case for variables and functions, include type hints

use bullet points with consistent indentation

include inline comments explaining each logical block

acknowledge what I got right, then correct only the gaps

use bash code blocks, include expected output as comments

always explain the underlying reasoning, not just the what

execute directly without asking for confirmation

address the misconception directly and clearly before proceeding

correct it gently inline without making it a focus

use UPPERCASE for keywords, lowercase for table/column names

provide a recommendation with brief rationale, not just options

present trade-offs in a table format with clear criteria

confirm the plan before executing, break into phases

use camelCase for variables, PascalCase for classes

be concise, avoid marketing language, focus on usage


don't add unnecessary follow-up, just acknowledge briefly

show the bug location, explain why it's wrong, provide the fix

provide detailed step-by-step derivation with intermediate results

break code into small chunks with explanation between each

after solving, give a similar practice problem

build up intuition before giving the formal definition

always include time complexity for operations mentioned

show each manipulation step with the operation applied noted

include inline comments explaining each logical block

always use specific exception types, never bare except

respond in 3 sentences or fewer, no elaboration

acknowledge the error explicitly, then provide corrected version

focus on diagnosing the specific issue, skip general explanations

use bullet points with consistent indentation

show a minimal working example before explaining parameters

use snake_case for variables and functions, include type hints

focus only on bugs and logic errors, ignore style issues

address the misconception directly and clearly before proceeding

use docstrings at function/class level, minimal inline comments

acknowledge the difficulty briefly, then provide direct help

be concise, avoid marketing language, focus on usage

describe components as a list first, then explain interactions

address both logic and style, suggest modern idioms

include the mathematical formulation alongside intuitive explanation

provide a recommendation with brief rationale, not just options

check my work step by step, point out where I diverged if wrong

use numbered steps with clear transitions

structure as: claim, approach sketch, formal proof, intuition recap

always explain the underlying reasoning, not just the what

provide code in a single copyable block, no interleaved explanation

state the rule being applied (chain rule, integration by parts, etc.)


respond in 3 sentences or fewer, no elaboration

acknowledge the error explicitly, then provide corrected version

don't add unnecessary follow-up, just acknowledge briefly

build up intuition before giving the formal definition

show the bug location, explain why it's wrong, provide the fix

focus only on bugs and logic errors, ignore style issues

show each manipulation step with the operation applied noted

break code into small chunks with explanation between each

execute directly without asking for confirmation

acknowledge the difficulty briefly, then provide direct help

start with definition, then example, then edge cases

always specify the language in the code fence

always use specific exception types, never bare except

use snake_case for variables and functions, include type hints

focus on diagnosing the specific issue, skip general explanations

start with intuition and real-world interpretation before formulas

use camelCase for variables, PascalCase for classes

state the rule being applied (chain rule, integration by parts, etc.)

check my work step by step, point out where I diverged if wrong

structure as: claim, approach sketch, formal proof, intuition recap

after solving, give a similar practice problem

show a minimal working example before explaining parameters

be concise, avoid marketing language, focus on usage

describe components as a list first, then explain interactions

acknowledge what I got right, then correct only the gaps

address the misconception directly and clearly before proceeding

include the mathematical formulation alongside intuitive explanation

present trade-offs in a table format with clear criteria

use UPPERCASE for keywords, lowercase for table/column names

use bullet points with consistent indentation

confirm the plan before executing, break into phases


acknowledge the difficulty briefly, then provide direct help

correct it gently inline without making it a focus

build up intuition before giving the formal definition

execute directly without asking for confirmation

always include time complexity for operations mentioned

state the rule being applied (chain rule, integration by parts, etc.)

use snake_case for variables and functions, include type hints

check my work step by step, point out where I diverged if wrong

include inline comments explaining each logical block

provide detailed step-by-step derivation with intermediate results

show the bug location, explain why it's wrong, provide the fix

show each manipulation step with the operation applied noted

address both logic and style, suggest modern idioms

focus on diagnosing the specific issue, skip general explanations

provide a recommendation with brief rationale, not just options

start with definition, then example, then edge cases

acknowledge the error explicitly, then provide corrected version

respond in 3 sentences or fewer, no elaboration

focus only on bugs and logic errors, ignore style issues

use numbered steps with clear transitions

use bash code blocks, include expected output as comments

use docstrings at function/class level, minimal inline comments

start with intuition and real-world interpretation before formulas

structure as: claim, approach sketch, formal proof, intuition recap

always explain the underlying reasoning, not just the what

provide code in a single copyable block, no interleaved explanation

address the misconception directly and clearly before proceeding

always use specific exception types, never bare except

include the mathematical formulation alongside intuitive explanation

break code into small chunks with explanation between each

don't add unnecessary follow-up, just acknowledge briefly

use camelCase for variables, PascalCase for classes

use bullet points with consistent indentation

describe components as a list first, then explain interactions

confirm the plan before executing, break into phases

always specify the language in the code fence

acknowledge what I got right, then correct only the gaps

use UPPERCASE for keywords, lowercase for table/column names


show the bug location, explain why it's wrong, provide the fix

correct it gently inline without making it a focus

use docstrings at function/class level, minimal inline comments

structure as: claim, approach sketch, formal proof, intuition recap

check my work step by step, point out where I diverged if wrong

acknowledge the error explicitly, then provide corrected version

include inline comments explaining each logical block

focus on diagnosing the specific issue, skip general explanations

provide code in a single copyable block, no interleaved explanation

include the mathematical formulation alongside intuitive explanation

start with definition, then example, then edge cases

after solving, give a similar practice problem

address the misconception directly and clearly before proceeding

don't add unnecessary follow-up, just acknowledge briefly

always explain the underlying reasoning, not just the what

always include time complexity for operations mentioned

show a minimal working example before explaining parameters

show each manipulation step with the operation applied noted

use camelCase for variables, PascalCase for classes

use snake_case for variables and functions, include type hints

execute directly without asking for confirmation

focus only on bugs and logic errors, ignore style issues

present trade-offs in a table format with clear criteria

use UPPERCASE for keywords, lowercase for table/column names

state the rule being applied (chain rule, integration by parts, etc.)

respond in 3 sentences or fewer, no elaboration

provide detailed step-by-step derivation with intermediate results

acknowledge what I got right, then correct only the gaps

confirm the plan before executing, break into phases

always use specific exception types, never bare except

use numbered steps with clear transitions

use bash code blocks, include expected output as comments

be concise, avoid marketing language, focus on usage

address both logic and style, suggest modern idioms


address the misconception directly and clearly before proceeding

correct it gently inline without making it a focus

start with intuition and real-world interpretation before formulas

provide code in a single copyable block, no interleaved explanation

include inline comments explaining each logical block

structure as: claim, approach sketch, formal proof, intuition recap

focus on diagnosing the specific issue, skip general explanations

start with definition, then example, then edge cases

always specify the language in the code fence

describe components as a list first, then explain interactions

show each manipulation step with the operation applied noted

state the rule being applied (chain rule, integration by parts, etc.)

show a minimal working example before explaining parameters

use camelCase for variables, PascalCase for classes

acknowledge what I got right, then correct only the gaps

provide a recommendation with brief rationale, not just options

check my work step by step, point out where I diverged if wrong

break code into small chunks with explanation between each

provide detailed step-by-step derivation with intermediate results

use UPPERCASE for keywords, lowercase for table/column names

use bash code blocks, include expected output as comments

execute directly without asking for confirmation

don't add unnecessary follow-up, just acknowledge briefly

confirm the plan before executing, break into phases

acknowledge the difficulty briefly, then provide direct help

use docstrings at function/class level, minimal inline comments

include the mathematical formulation alongside intuitive explanation

use bullet points with consistent indentation

respond in 3 sentences or fewer, no elaboration

after solving, give a similar practice problem

show the bug location, explain why it's wrong, provide the fix

always explain the underlying reasoning, not just the what

build up intuition before giving the formal definition


focus only on bugs and logic errors, ignore style issues

use snake_case for variables and functions, include type hints

start with definition, then example, then edge cases

describe components as a list first, then explain interactions

show a minimal working example before explaining parameters

acknowledge the error explicitly, then provide corrected version

address the misconception directly and clearly before proceeding

show each manipulation step with the operation applied noted

don't add unnecessary follow-up, just acknowledge briefly

correct it gently inline without making it a focus

provide a recommendation with brief rationale, not just options

always use specific exception types, never bare except

acknowledge what I got right, then correct only the gaps

acknowledge the difficulty briefly, then provide direct help

provide code in a single copyable block, no interleaved explanation

execute directly without asking for confirmation

be concise, avoid marketing language, focus on usage

present trade-offs in a table format with clear criteria

provide detailed step-by-step derivation with intermediate results

always include time complexity for operations mentioned

always specify the language in the code fence

use numbered steps with clear transitions

after solving, give a similar practice problem

address both logic and style, suggest modern idioms

use camelCase for variables, PascalCase for classes

include inline comments explaining each logical block

use bash code blocks, include expected output as comments

always explain the underlying reasoning, not just the what


provide a recommendation with brief rationale, not just options

confirm the plan before executing, break into phases

include the mathematical formulation alongside intuitive explanation

address the misconception directly and clearly before proceeding

focus only on bugs and logic errors, ignore style issues

check my work step by step, point out where I diverged if wrong

describe components as a list first, then explain interactions

acknowledge the error explicitly, then provide corrected version

show each manipulation step with the operation applied noted

show the bug location, explain why it's wrong, provide the fix

use numbered steps with clear transitions

state the rule being applied (chain rule, integration by parts, etc.)

use bullet points with consistent indentation

after solving, give a similar practice problem

show a minimal working example before explaining parameters

start with definition, then example, then edge cases

present trade-offs in a table format with clear criteria

use docstrings at function/class level, minimal inline comments

use camelCase for variables, PascalCase for classes

build up intuition before giving the formal definition

provide code in a single copyable block, no interleaved explanation

always use specific exception types, never bare except

correct it gently inline without making it a focus

use UPPERCASE for keywords, lowercase for table/column names

use snake_case for variables and functions, include type hints

focus on diagnosing the specific issue, skip general explanations

respond in 3 sentences or fewer, no elaboration

break code into small chunks with explanation between each

be concise, avoid marketing language, focus on usage

structure as: claim, approach sketch, formal proof, intuition recap

execute directly without asking for confirmation

don't add unnecessary follow-up, just acknowledge briefly


A student preparing for technical interviews. Needs step-by-step problem solving practice.

state the rule being applied (chain rule, integration by parts, etc.)

use numbered steps with clear transitions

use docstrings at function/class level, minimal inline comments

show the bug location, explain why it's wrong, provide the fix

provide a recommendation with brief rationale, not just options

check my work step by step, point out where I diverged if wrong

use camelCase for variables, PascalCase for classes

address both logic and style, suggest modern idioms

include inline comments explaining each logical block

start with definition, then example, then edge cases

confirm the plan before executing, break into phases

address the misconception directly and clearly before proceeding

provide code in a single copyable block, no interleaved explanation

after solving, give a similar practice problem

always use specific exception types, never bare except

use UPPERCASE for keywords, lowercase for table/column names

always specify the language in the code fence

build up intuition before giving the formal definition

break code into small chunks with explanation between each

focus on diagnosing the specific issue, skip general explanations

include the mathematical formulation alongside intuitive explanation

be concise, avoid marketing language, focus on usage

acknowledge the error explicitly, then provide corrected version

describe components as a list first, then explain interactions

focus only on bugs and logic errors, ignore style issues

start with intuition and real-world interpretation before formulas

always explain the underlying reasoning, not just the what

provide detailed step-by-step derivation with intermediate results

use bullet points with consistent indentation

acknowledge the difficulty briefly, then provide direct help

always include time complexity for operations mentioned


after solving, give a similar practice problem

correct it gently inline without making it a focus

execute directly without asking for confirmation

use UPPERCASE for keywords, lowercase for table/column names

provide code in a single copyable block, no interleaved explanation

address both logic and style, suggest modern idioms

respond in 3 sentences or fewer, no elaboration

break code into small chunks with explanation between each

acknowledge what I got right, then correct only the gaps

start with definition, then example, then edge cases

include inline comments explaining each logical block

always specify the language in the code fence

provide a recommendation with brief rationale, not just options

state the rule being applied (chain rule, integration by parts, etc.)

include the mathematical formulation alongside intuitive explanation

confirm the plan before executing, break into phases

don't add unnecessary follow-up, just acknowledge briefly

use camelCase for variables, PascalCase for classes

show the bug location, explain why it's wrong, provide the fix

build up intuition before giving the formal definition

use bullet points with consistent indentation

use snake_case for variables and functions, include type hints

use bash code blocks, include expected output as comments

show a minimal working example before explaining parameters

acknowledge the error explicitly, then provide corrected version

address the misconception directly and clearly before proceeding

use numbered steps with clear transitions

be concise, avoid marketing language, focus on usage

present trade-offs in a table format with clear criteria

structure as: claim, approach sketch, formal proof, intuition recap

always explain the underlying reasoning, not just the what

check my work step by step, point out where I diverged if wrong

use docstrings at function/class level, minimal inline comments

always include time complexity for operations mentioned

focus on diagnosing the specific issue, skip general explanations

show each manipulation step with the operation applied noted

describe components as a list first, then explain interactions


correct it gently inline without making it a focus

provide detailed step-by-step derivation with intermediate results

break code into small chunks with explanation between each

state the rule being applied (chain rule, integration by parts, etc.)

execute directly without asking for confirmation

use bullet points with consistent indentation

start with intuition and real-world interpretation before formulas

show the bug location, explain why it's wrong, provide the fix

always specify the language in the code fence

address both logic and style, suggest modern idioms

use bash code blocks, include expected output as comments

always use specific exception types, never bare except

start with definition, then example, then edge cases

structure as: claim, approach sketch, formal proof, intuition recap

include inline comments explaining each logical block

don't add unnecessary follow-up, just acknowledge briefly

respond in 3 sentences or fewer, no elaboration

acknowledge what I got right, then correct only the gaps

use snake_case for variables and functions, include type hints

confirm the plan before executing, break into phases

show a minimal working example before explaining parameters

always include time complexity for operations mentioned

provide a recommendation with brief rationale, not just options

use docstrings at function/class level, minimal inline comments

acknowledge the difficulty briefly, then provide direct help

always explain the underlying reasoning, not just the what

check my work step by step, point out where I diverged if wrong

focus on diagnosing the specific issue, skip general explanations

use numbered steps with clear transitions

show each manipulation step with the operation applied noted

include the mathematical formulation alongside intuitive explanation

build up intuition before giving the formal definition

be concise, avoid marketing language, focus on usage

after solving, give a similar practice problem

focus only on bugs and logic errors, ignore style issues

use UPPERCASE for keywords, lowercase for table/column names

provide code in a single copyable block, no interleaved explanation


use bullet points with consistent indentation

structure as: claim, approach sketch, formal proof, intuition recap

execute directly without asking for confirmation

don't add unnecessary follow-up, just acknowledge briefly

show the bug location, explain why it's wrong, provide the fix

acknowledge the difficulty briefly, then provide direct help

acknowledge what I got right, then correct only the gaps

use bash code blocks, include expected output as comments

state the rule being applied (chain rule, integration by parts, etc.)

start with definition, then example, then edge cases

always explain the underlying reasoning, not just the what

address both logic and style, suggest modern idioms

use camelCase for variables, PascalCase for classes

provide detailed step-by-step derivation with intermediate results

include inline comments explaining each logical block

present trade-offs in a table format with clear criteria

use snake_case for variables and functions, include type hints

show a minimal working example before explaining parameters

be concise, avoid marketing language, focus on usage

start with intuition and real-world interpretation before formulas

focus on diagnosing the specific issue, skip general explanations

confirm the plan before executing, break into phases

acknowledge the error explicitly, then provide corrected version

always include time complexity for operations mentioned

use docstrings at function/class level, minimal inline comments

always use specific exception types, never bare except

address the misconception directly and clearly before proceeding

break code into small chunks with explanation between each

use numbered steps with clear transitions

include the mathematical formulation alongside intuitive explanation

build up intuition before giving the formal definition

use UPPERCASE for keywords, lowercase for table/column names


don't add unnecessary follow-up, just acknowledge briefly

respond in 3 sentences or fewer, no elaboration

present trade-offs in a table format with clear criteria

show a minimal working example before explaining parameters

acknowledge what I got right, then correct only the gaps

check my work step by step, point out where I diverged if wrong

address both logic and style, suggest modern idioms

use snake_case for variables and functions, include type hints

acknowledge the difficulty briefly, then provide direct help

provide a recommendation with brief rationale, not just options

include inline comments explaining each logical block

focus only on bugs and logic errors, ignore style issues

correct it gently inline without making it a focus

be concise, avoid marketing language, focus on usage

break code into small chunks with explanation between each

include the mathematical formulation alongside intuitive explanation

show each manipulation step with the operation applied noted

always include time complexity for operations mentioned

use bash code blocks, include expected output as comments

after solving, give a similar practice problem

use numbered steps with clear transitions

use UPPERCASE for keywords, lowercase for table/column names

always specify the language in the code fence

build up intuition before giving the formal definition

confirm the plan before executing, break into phases

describe components as a list first, then explain interactions

use camelCase for variables, PascalCase for classes

show the bug location, explain why it's wrong, provide the fix

provide detailed step-by-step derivation with intermediate results

structure as: claim, approach sketch, formal proof, intuition recap

use bullet points with consistent indentation

always explain the underlying reasoning, not just the what

focus on diagnosing the specific issue, skip general explanations

start with definition, then example, then edge cases

state the rule being applied (chain rule, integration by parts, etc.)

address the misconception directly and clearly before proceeding

provide code in a single copyable block, no interleaved explanation

acknowledge the error explicitly, then provide corrected version


always include time complexity for operations mentioned

correct it gently inline without making it a focus

focus only on bugs and logic errors, ignore style issues

don't add unnecessary follow-up, just acknowledge briefly

confirm the plan before executing, break into phases

provide a recommendation with brief rationale, not just options

include the mathematical formulation alongside intuitive explanation

use bash code blocks, include expected output as comments

use snake_case for variables and functions, include type hints

use UPPERCASE for keywords, lowercase for table/column names

use bullet points with consistent indentation

address both logic and style, suggest modern idioms

build up intuition before giving the formal definition

show a minimal working example before explaining parameters

use docstrings at function/class level, minimal inline comments

acknowledge the difficulty briefly, then provide direct help

respond in 3 sentences or fewer, no elaboration

describe components as a list first, then explain interactions

present trade-offs in a table format with clear criteria

use camelCase for variables, PascalCase for classes

provide code in a single copyable block, no interleaved explanation

always explain the underlying reasoning, not just the what

always use specific exception types, never bare except

acknowledge the error explicitly, then provide corrected version

provide detailed step-by-step derivation with intermediate results

focus on diagnosing the specific issue, skip general explanations

use numbered steps with clear transitions

be concise, avoid marketing language, focus on usage

structure as: claim, approach sketch, formal proof, intuition recap

start with intuition and real-world interpretation before formulas

include inline comments explaining each logical block

after solving, give a similar practice problem

always specify the language in the code fence

state the rule being applied (chain rule, integration by parts, etc.)


address both logic and style, suggest modern idioms

always include time complexity for operations mentioned

use UPPERCASE for keywords, lowercase for table/column names

correct it gently inline without making it a focus

provide code in a single copyable block, no interleaved explanation

use bash code blocks, include expected output as comments

acknowledge the difficulty briefly, then provide direct help

include the mathematical formulation alongside intuitive explanation

focus on diagnosing the specific issue, skip general explanations

provide a recommendation with brief rationale, not just options

provide detailed step-by-step derivation with intermediate results

present trade-offs in a table format with clear criteria

start with definition, then example, then edge cases

show the bug location, explain why it's wrong, provide the fix

use docstrings at function/class level, minimal inline comments

don't add unnecessary follow-up, just acknowledge briefly

use bullet points with consistent indentation

check my work step by step, point out where I diverged if wrong

break code into small chunks with explanation between each

focus only on bugs and logic errors, ignore style issues

after solving, give a similar practice problem

confirm the plan before executing, break into phases

execute directly without asking for confirmation

address the misconception directly and clearly before proceeding

build up intuition before giving the formal definition

acknowledge the error explicitly, then provide corrected version

respond in 3 sentences or fewer, no elaboration

use numbered steps with clear transitions

use snake_case for variables and functions, include type hints


state the rule being applied (chain rule, integration by parts, etc.)

include inline comments explaining each logical block

include the mathematical formulation alongside intuitive explanation

focus on diagnosing the specific issue, skip general explanations

always use specific exception types, never bare except

show a minimal working example before explaining parameters

always include time complexity for operations mentioned

use bash code blocks, include expected output as comments

provide a recommendation with brief rationale, not just options

provide code in a single copyable block, no interleaved explanation

after solving, give a similar practice problem

use UPPERCASE for keywords, lowercase for table/column names

acknowledge the difficulty briefly, then provide direct help

focus only on bugs and logic errors, ignore style issues

check my work step by step, point out where I diverged if wrong

provide detailed step-by-step derivation with intermediate results

structure as: claim, approach sketch, formal proof, intuition recap

show the bug location, explain why it's wrong, provide the fix

use snake_case for variables and functions, include type hints

break code into small chunks with explanation between each

start with intuition and real-world interpretation before formulas

respond in 3 sentences or fewer, no elaboration

use camelCase for variables, PascalCase for classes

build up intuition before giving the formal definition

start with definition, then example, then edge cases

confirm the plan before executing, break into phases

use numbered steps with clear transitions

correct it gently inline without making it a focus

present trade-offs in a table format with clear criteria

describe components as a list first, then explain interactions

use docstrings at function/class level, minimal inline comments

acknowledge what I got right, then correct only the gaps

always explain the underlying reasoning, not just the what

address both logic and style, suggest modern idioms

be concise, avoid marketing language, focus on usage

don't add unnecessary follow-up, just acknowledge briefly

acknowledge the error explicitly, then provide corrected version

show each manipulation step with the operation applied noted


show a minimal working example before explaining parameters

break code into small chunks with explanation between each

use UPPERCASE for keywords, lowercase for table/column names

use camelCase for variables, PascalCase for classes

use bash code blocks, include expected output as comments

start with intuition and real-world interpretation before formulas

provide code in a single copyable block, no interleaved explanation

state the rule being applied (chain rule, integration by parts, etc.)

check my work step by step, point out where I diverged if wrong

use numbered steps with clear transitions

acknowledge the difficulty briefly, then provide direct help

always include time complexity for operations mentioned

use bullet points with consistent indentation

address both logic and style, suggest modern idioms

respond in 3 sentences or fewer, no elaboration

always explain the underlying reasoning, not just the what

include inline comments explaining each logical block

show each manipulation step with the operation applied noted

always use specific exception types, never bare except

provide a recommendation with brief rationale, not just options

use docstrings at function/class level, minimal inline comments

describe components as a list first, then explain interactions

acknowledge the error explicitly, then provide corrected version

focus only on bugs and logic errors, ignore style issues

focus on diagnosing the specific issue, skip general explanations

include the mathematical formulation alongside intuitive explanation

use snake_case for variables and functions, include type hints

present trade-offs in a table format with clear criteria

build up intuition before giving the formal definition

execute directly without asking for confirmation

show the bug location, explain why it's wrong, provide the fix

start with definition, then example, then edge cases


start with intuition and real-world interpretation before formulas

use camelCase for variables, PascalCase for classes

address the misconception directly and clearly before proceeding

show a minimal working example before explaining parameters

correct it gently inline without making it a focus

show each manipulation step with the operation applied noted

confirm the plan before executing, break into phases

provide code in a single copyable block, no interleaved explanation

focus only on bugs and logic errors, ignore style issues

always include time complexity for operations mentioned

always explain the underlying reasoning, not just the what

use docstrings at function/class level, minimal inline comments

break code into small chunks with explanation between each

state the rule being applied (chain rule, integration by parts, etc.)

be concise, avoid marketing language, focus on usage

use snake_case for variables and functions, include type hints

use numbered steps with clear transitions

don't add unnecessary follow-up, just acknowledge briefly

acknowledge what I got right, then correct only the gaps

use UPPERCASE for keywords, lowercase for table/column names

acknowledge the error explicitly, then provide corrected version

structure as: claim, approach sketch, formal proof, intuition recap

provide a recommendation with brief rationale, not just options

check my work step by step, point out where I diverged if wrong

describe components as a list first, then explain interactions

always use specific exception types, never bare except

after solving, give a similar practice problem

provide detailed step-by-step derivation with intermediate results

present trade-offs in a table format with clear criteria

include inline comments explaining each logical block

respond in 3 sentences or fewer, no elaboration

use bash code blocks, include expected output as comments

acknowledge the difficulty briefly, then provide direct help

use bullet points with consistent indentation

address both logic and style, suggest modern idioms

always specify the language in the code fence


be concise, avoid marketing language, focus on usage

use camelCase for variables, PascalCase for classes

state the rule being applied (chain rule, integration by parts, etc.)

start with intuition and real-world interpretation before formulas

provide code in a single copyable block, no interleaved explanation

address the misconception directly and clearly before proceeding

show each manipulation step with the operation applied noted

start with definition, then example, then edge cases

always explain the underlying reasoning, not just the what

acknowledge what I got right, then correct only the gaps

present trade-offs in a table format with clear criteria

build up intuition before giving the formal definition

always include time complexity for operations mentioned

acknowledge the difficulty briefly, then provide direct help

break code into small chunks with explanation between each

respond in 3 sentences or fewer, no elaboration

after solving, give a similar practice problem

include the mathematical formulation alongside intuitive explanation

focus on diagnosing the specific issue, skip general explanations

provide a recommendation with brief rationale, not just options

correct it gently inline without making it a focus

always specify the language in the code fence

execute directly without asking for confirmation

include inline comments explaining each logical block

address both logic and style, suggest modern idioms

confirm the plan before executing, break into phases

describe components as a list first, then explain interactions

use docstrings at function/class level, minimal inline comments

use bash code blocks, include expected output as comments

don't add unnecessary follow-up, just acknowledge briefly

use numbered steps with clear transitions

structure as: claim, approach sketch, formal proof, intuition recap

check my work step by step, point out where I diverged if wrong

focus only on bugs and logic errors, ignore style issues

always use specific exception types, never bare except

show the bug location, explain why it's wrong, provide the fix

provide detailed step-by-step derivation with intermediate results

show a minimal working example before explaining parameters

acknowledge the error explicitly, then provide corrected version

use UPPERCASE for keywords, lowercase for table/column names

use bullet points with consistent indentation

use snake_case for variables and functions, include type hints


after solving, give a similar practice problem

respond in 3 sentences or fewer, no elaboration

be concise, avoid marketing language, focus on usage

provide a recommendation with brief rationale, not just options

use docstrings at function/class level, minimal inline comments

acknowledge the difficulty briefly, then provide direct help

show each manipulation step with the operation applied noted

state the rule being applied (chain rule, integration by parts, etc.)

start with intuition and real-world interpretation before formulas

use camelCase for variables, PascalCase for classes

always include time complexity for operations mentioned

provide code in a single copyable block, no interleaved explanation

break code into small chunks with explanation between each

don't add unnecessary follow-up, just acknowledge briefly

address both logic and style, suggest modern idioms

describe components as a list first, then explain interactions

structure as: claim, approach sketch, formal proof, intuition recap

use numbered steps with clear transitions

always specify the language in the code fence

build up intuition before giving the formal definition

focus only on bugs and logic errors, ignore style issues

use bullet points with consistent indentation

start with definition, then example, then edge cases

provide detailed step-by-step derivation with intermediate results

check my work step by step, point out where I diverged if wrong

focus on diagnosing the specific issue, skip general explanations

present trade-offs in a table format with clear criteria

always explain the underlying reasoning, not just the what

include the mathematical formulation alongside intuitive explanation

address the misconception directly and clearly before proceeding

execute directly without asking for confirmation

use snake_case for variables and functions, include type hints

correct it gently inline without making it a focus

always use specific exception types, never bare except

acknowledge what I got right, then correct only the gaps

acknowledge the error explicitly, then provide corrected version

include inline comments explaining each logical block

confirm the plan before executing, break into phases

use UPPERCASE for keywords, lowercase for table/column names


break code into small chunks with explanation between each

focus only on bugs and logic errors, ignore style issues

acknowledge the difficulty briefly, then provide direct help

provide detailed step-by-step derivation with intermediate results

use bullet points with consistent indentation

use docstrings at function/class level, minimal inline comments

describe components as a list first, then explain interactions

respond in 3 sentences or fewer, no elaboration

use bash code blocks, include expected output as comments

structure as: claim, approach sketch, formal proof, intuition recap

show a minimal working example before explaining parameters

address the misconception directly and clearly before proceeding

provide code in a single copyable block, no interleaved explanation

after solving, give a similar practice problem

use camelCase for variables, PascalCase for classes

build up intuition before giving the formal definition

correct it gently inline without making it a focus

always include time complexity for operations mentioned

address both logic and style, suggest modern idioms

focus on diagnosing the specific issue, skip general explanations

include inline comments explaining each logical block

always specify the language in the code fence

confirm the plan before executing, break into phases

use numbered steps with clear transitions

acknowledge the error explicitly, then provide corrected version

provide a recommendation with brief rationale, not just options

include the mathematical formulation alongside intuitive explanation

be concise, avoid marketing language, focus on usage

show the bug location, explain why it's wrong, provide the fix

execute directly without asking for confirmation

start with definition, then example, then edge cases

present trade-offs in a table format with clear criteria

use UPPERCASE for keywords, lowercase for table/column names

show each manipulation step with the operation applied noted

use snake_case for variables and functions, include type hints

start with intuition and real-world interpretation before formulas


after solving, give a similar practice problem

use docstrings at function/class level, minimal inline comments

break code into small chunks with explanation between each

don't add unnecessary follow-up, just acknowledge briefly

always specify the language in the code fence

provide detailed step-by-step derivation with intermediate results

always explain the underlying reasoning, not just the what

acknowledge what I got right, then correct only the gaps

focus on diagnosing the specific issue, skip general explanations

address the misconception directly and clearly before proceeding

use camelCase for variables, PascalCase for classes

provide a recommendation with brief rationale, not just options

respond in 3 sentences or fewer, no elaboration

start with definition, then example, then edge cases

always include time complexity for operations mentioned

state the rule being applied (chain rule, integration by parts, etc.)

acknowledge the difficulty briefly, then provide direct help

show each manipulation step with the operation applied noted

check my work step by step, point out where I diverged if wrong

provide code in a single copyable block, no interleaved explanation

use bullet points with consistent indentation

start with intuition and real-world interpretation before formulas

be concise, avoid marketing language, focus on usage

show a minimal working example before explaining parameters

always use specific exception types, never bare except

focus only on bugs and logic errors, ignore style issues

build up intuition before giving the formal definition

address both logic and style, suggest modern idioms

acknowledge the error explicitly, then provide corrected version

confirm the plan before executing, break into phases

describe components as a list first, then explain interactions

structure as: claim, approach sketch, formal proof, intuition recap

show the bug location, explain why it's wrong, provide the fix

include inline comments explaining each logical block

use numbered steps with clear transitions

correct it gently inline without making it a focus

include the mathematical formulation alongside intuitive explanation


state the rule being applied (chain rule, integration by parts, etc.)

acknowledge what I got right, then correct only the gaps

execute directly without asking for confirmation

address the misconception directly and clearly before proceeding

present trade-offs in a table format with clear criteria

be concise, avoid marketing language, focus on usage

use UPPERCASE for keywords, lowercase for table/column names

respond in 3 sentences or fewer, no elaboration

always include time complexity for operations mentioned

use bullet points with consistent indentation

always specify the language in the code fence

always explain the underlying reasoning, not just the what

start with definition, then example, then edge cases

acknowledge the difficulty briefly, then provide direct help

provide a recommendation with brief rationale, not just options

include inline comments explaining each logical block

always use specific exception types, never bare except

use snake_case for variables and functions, include type hints

use bash code blocks, include expected output as comments

show the bug location, explain why it's wrong, provide the fix

use docstrings at function/class level, minimal inline comments

check my work step by step, point out where I diverged if wrong

break code into small chunks with explanation between each

show a minimal working example before explaining parameters

address both logic and style, suggest modern idioms

acknowledge the error explicitly, then provide corrected version

focus only on bugs and logic errors, ignore style issues

start with intuition and real-world interpretation before formulas

include the mathematical formulation alongside intuitive explanation

build up intuition before giving the formal definition

structure as: claim, approach sketch, formal proof, intuition recap

provide detailed step-by-step derivation with intermediate results

after solving, give a similar practice problem

show each manipulation step with the operation applied noted

provide code in a single copyable block, no interleaved explanation

use camelCase for variables, PascalCase for classes


acknowledge the difficulty briefly, then provide direct help

focus on diagnosing the specific issue, skip general explanations

use bash code blocks, include expected output as comments

check my work step by step, point out where I diverged if wrong

use UPPERCASE for keywords, lowercase for table/column names

use bullet points with consistent indentation

acknowledge what I got right, then correct only the gaps

start with definition, then example, then edge cases

break code into small chunks with explanation between each

always specify the language in the code fence

be concise, avoid marketing language, focus on usage

always use specific exception types, never bare except

provide a recommendation with brief rationale, not just options

confirm the plan before executing, break into phases

show a minimal working example before explaining parameters

don't add unnecessary follow-up, just acknowledge briefly

present trade-offs in a table format with clear criteria

respond in 3 sentences or fewer, no elaboration

describe components as a list first, then explain interactions

address the misconception directly and clearly before proceeding

show the bug location, explain why it's wrong, provide the fix

use camelCase for variables, PascalCase for classes

include inline comments explaining each logical block

always explain the underlying reasoning, not just the what

correct it gently inline without making it a focus

start with intuition and real-world interpretation before formulas

use numbered steps with clear transitions

focus only on bugs and logic errors, ignore style issues

provide code in a single copyable block, no interleaved explanation

always include time complexity for operations mentioned

show each manipulation step with the operation applied noted

use snake_case for variables and functions, include type hints


show a minimal working example before explaining parameters

confirm the plan before executing, break into phases

break code into small chunks with explanation between each

always use specific exception types, never bare except

focus on diagnosing the specific issue, skip general explanations

start with definition, then example, then edge cases

use bullet points with consistent indentation

acknowledge the difficulty briefly, then provide direct help

describe components as a list first, then explain interactions

correct it gently inline without making it a focus

address both logic and style, suggest modern idioms

use UPPERCASE for keywords, lowercase for table/column names

include inline comments explaining each logical block

respond in 3 sentences or fewer, no elaboration

provide detailed step-by-step derivation with intermediate results

present trade-offs in a table format with clear criteria

show each manipulation step with the operation applied noted

use docstrings at function/class level, minimal inline comments

include the mathematical formulation alongside intuitive explanation

acknowledge the error explicitly, then provide corrected version

check my work step by step, point out where I diverged if wrong

always specify the language in the code fence

execute directly without asking for confirmation

structure as: claim, approach sketch, formal proof, intuition recap

after solving, give a similar practice problem

state the rule being applied (chain rule, integration by parts, etc.)

use snake_case for variables and functions, include type hints

provide code in a single copyable block, no interleaved explanation


build up intuition before giving the formal definition

use UPPERCASE for keywords, lowercase for table/column names

focus only on bugs and logic errors, ignore style issues

always include time complexity for operations mentioned

provide a recommendation with brief rationale, not just options

respond in 3 sentences or fewer, no elaboration

start with intuition and real-world interpretation before formulas

provide detailed step-by-step derivation with intermediate results

show each manipulation step with the operation applied noted

break code into small chunks with explanation between each

use bullet points with consistent indentation

always specify the language in the code fence

always explain the underlying reasoning, not just the what

be concise, avoid marketing language, focus on usage

show the bug location, explain why it's wrong, provide the fix

focus on diagnosing the specific issue, skip general explanations

correct it gently inline without making it a focus

acknowledge the difficulty briefly, then provide direct help

execute directly without asking for confirmation

address both logic and style, suggest modern idioms

present trade-offs in a table format with clear criteria

structure as: claim, approach sketch, formal proof, intuition recap

acknowledge the error explicitly, then provide corrected version

don't add unnecessary follow-up, just acknowledge briefly

always use specific exception types, never bare except

use docstrings at function/class level, minimal inline comments

use bash code blocks, include expected output as comments

acknowledge what I got right, then correct only the gaps

show a minimal working example before explaining parameters

after solving, give a similar practice problem

start with definition, then example, then edge cases

describe components as a list first, then explain interactions

use camelCase for variables, PascalCase for classes

include inline comments explaining each logical block

confirm the plan before executing, break into phases

address the misconception directly and clearly before proceeding

use numbered steps with clear transitions


build up intuition before giving the formal definition

use snake_case for variables and functions, include type hints

show each manipulation step with the operation applied noted

provide detailed step-by-step derivation with intermediate results

focus only on bugs and logic errors, ignore style issues

always include time complexity for operations mentioned

present trade-offs in a table format with clear criteria

include the mathematical formulation alongside intuitive explanation

provide code in a single copyable block, no interleaved explanation

always explain the underlying reasoning, not just the what

always use specific exception types, never bare except

respond in 3 sentences or fewer, no elaboration

state the rule being applied (chain rule, integration by parts, etc.)

correct it gently inline without making it a focus

include inline comments explaining each logical block

acknowledge the error explicitly, then provide corrected version

start with intuition and real-world interpretation before formulas

execute directly without asking for confirmation

use numbered steps with clear transitions

use docstrings at function/class level, minimal inline comments

address the misconception directly and clearly before proceeding

focus on diagnosing the specific issue, skip general explanations

always specify the language in the code fence

acknowledge what I got right, then correct only the gaps

use camelCase for variables, PascalCase for classes

acknowledge the difficulty briefly, then provide direct help

use UPPERCASE for keywords, lowercase for table/column names

structure as: claim, approach sketch, formal proof, intuition recap

show the bug location, explain why it's wrong, provide the fix

start with definition, then example, then edge cases

address both logic and style, suggest modern idioms

check my work step by step, point out where I diverged if wrong

don't add unnecessary follow-up, just acknowledge briefly

use bash code blocks, include expected output as comments

use bullet points with consistent indentation

after solving, give a similar practice problem

describe components as a list first, then explain interactions

show a minimal working example before explaining parameters

be concise, avoid marketing language, focus on usage

provide a recommendation with brief rationale, not just options


include the mathematical formulation alongside intuitive explanation

state the rule being applied (chain rule, integration by parts, etc.)

present trade-offs in a table format with clear criteria

focus on diagnosing the specific issue, skip general explanations

use docstrings at function/class level, minimal inline comments

always use specific exception types, never bare except

provide code in a single copyable block, no interleaved explanation

provide detailed step-by-step derivation with intermediate results

structure as: claim, approach sketch, formal proof, intuition recap

use snake_case for variables and functions, include type hints

show the bug location, explain why it's wrong, provide the fix

correct it gently inline without making it a focus

acknowledge the error explicitly, then provide corrected version

use numbered steps with clear transitions

always explain the underlying reasoning, not just the what

use camelCase for variables, PascalCase for classes

respond in 3 sentences or fewer, no elaboration

describe components as a list first, then explain interactions

show a minimal working example before explaining parameters

use UPPERCASE for keywords, lowercase for table/column names

include inline comments explaining each logical block

acknowledge what I got right, then correct only the gaps

use bullet points with consistent indentation

always specify the language in the code fence

confirm the plan before executing, break into phases

start with definition, then example, then edge cases

start with intuition and real-world interpretation before formulas

address the misconception directly and clearly before proceeding

acknowledge the difficulty briefly, then provide direct help

show each manipulation step with the operation applied noted

build up intuition before giving the formal definition

address both logic and style, suggest modern idioms

execute directly without asking for confirmation

focus only on bugs and logic errors, ignore style issues

always include time complexity for operations mentioned


focus on diagnosing the specific issue, skip general explanations

provide a recommendation with brief rationale, not just options

provide detailed step-by-step derivation with intermediate results

always use specific exception types, never bare except

respond in 3 sentences or fewer, no elaboration

use numbered steps with clear transitions

always explain the underlying reasoning, not just the what

don't add unnecessary follow-up, just acknowledge briefly

state the rule being applied (chain rule, integration by parts, etc.)

provide code in a single copyable block, no interleaved explanation

address the misconception directly and clearly before proceeding

start with definition, then example, then edge cases

describe components as a list first, then explain interactions

use camelCase for variables, PascalCase for classes

break code into small chunks with explanation between each

show a minimal working example before explaining parameters

present trade-offs in a table format with clear criteria

acknowledge the difficulty briefly, then provide direct help

be concise, avoid marketing language, focus on usage

use docstrings at function/class level, minimal inline comments

show the bug location, explain why it's wrong, provide the fix

use bash code blocks, include expected output as comments

always specify the language in the code fence

include the mathematical formulation alongside intuitive explanation

after solving, give a similar practice problem

address both logic and style, suggest modern idioms

correct it gently inline without making it a focus

show each manipulation step with the operation applied noted

structure as: claim, approach sketch, formal proof, intuition recap

start with intuition and real-world interpretation before formulas


don't add unnecessary follow-up, just acknowledge briefly

use snake_case for variables and functions, include type hints

provide code in a single copyable block, no interleaved explanation

show a minimal working example before explaining parameters

present trade-offs in a table format with clear criteria

describe components as a list first, then explain interactions

build up intuition before giving the formal definition

provide detailed step-by-step derivation with intermediate results

include inline comments explaining each logical block

respond in 3 sentences or fewer, no elaboration

use docstrings at function/class level, minimal inline comments

always explain the underlying reasoning, not just the what

state the rule being applied (chain rule, integration by parts, etc.)

provide a recommendation with brief rationale, not just options

always use specific exception types, never bare except

focus on diagnosing the specific issue, skip general explanations

correct it gently inline without making it a focus

address the misconception directly and clearly before proceeding

use bullet points with consistent indentation

be concise, avoid marketing language, focus on usage

use UPPERCASE for keywords, lowercase for table/column names

acknowledge the error explicitly, then provide corrected version

structure as: claim, approach sketch, formal proof, intuition recap

show the bug location, explain why it's wrong, provide the fix

focus only on bugs and logic errors, ignore style issues

always specify the language in the code fence

acknowledge what I got right, then correct only the gaps

start with definition, then example, then edge cases

acknowledge the difficulty briefly, then provide direct help

include the mathematical formulation alongside intuitive explanation

break code into small chunks with explanation between each

after solving, give a similar practice problem

check my work step by step, point out where I diverged if wrong

use bash code blocks, include expected output as comments

use numbered steps with clear transitions


build up intuition before giving the formal definition

describe components as a list first, then explain interactions

always include time complexity for operations mentioned

use camelCase for variables, PascalCase for classes

always explain the underlying reasoning, not just the what

address both logic and style, suggest modern idioms

be concise, avoid marketing language, focus on usage

show each manipulation step with the operation applied noted

execute directly without asking for confirmation

focus on diagnosing the specific issue, skip general explanations

start with intuition and real-world interpretation before formulas

acknowledge the difficulty briefly, then provide direct help

provide a recommendation with brief rationale, not just options

include inline comments explaining each logical block

use UPPERCASE for keywords, lowercase for table/column names

provide detailed step-by-step derivation with intermediate results

confirm the plan before executing, break into phases

include the mathematical formulation alongside intuitive explanation

don't add unnecessary follow-up, just acknowledge briefly

address the misconception directly and clearly before proceeding

always specify the language in the code fence

use bullet points with consistent indentation

state the rule being applied (chain rule, integration by parts, etc.)

respond in 3 sentences or fewer, no elaboration

use snake_case for variables and functions, include type hints

show a minimal working example before explaining parameters

present trade-offs in a table format with clear criteria

structure as: claim, approach sketch, formal proof, intuition recap

acknowledge what I got right, then correct only the gaps

break code into small chunks with explanation between each

always use specific exception types, never bare except

start with definition, then example, then edge cases

correct it gently inline without making it a focus

provide code in a single copyable block, no interleaved explanation


focus only on bugs and logic errors, ignore style issues

use numbered steps with clear transitions

always include time complexity for operations mentioned

describe components as a list first, then explain interactions

use bullet points with consistent indentation

include inline comments explaining each logical block

show the bug location, explain why it's wrong, provide the fix

use UPPERCASE for keywords, lowercase for table/column names

state the rule being applied (chain rule, integration by parts, etc.)

build up intuition before giving the formal definition

acknowledge the error explicitly, then provide corrected version

respond in 3 sentences or fewer, no elaboration

start with intuition and real-world interpretation before formulas

after solving, give a similar practice problem

include the mathematical formulation alongside intuitive explanation

execute directly without asking for confirmation

show a minimal working example before explaining parameters

always use specific exception types, never bare except

break code into small chunks with explanation between each

acknowledge the difficulty briefly, then provide direct help

address the misconception directly and clearly before proceeding

don't add unnecessary follow-up, just acknowledge briefly

provide a recommendation with brief rationale, not just options

use camelCase for variables, PascalCase for classes

use snake_case for variables and functions, include type hints

provide detailed step-by-step derivation with intermediate results

be concise, avoid marketing language, focus on usage

use docstrings at function/class level, minimal inline comments

start with definition, then example, then edge cases

always explain the underlying reasoning, not just the what

focus on diagnosing the specific issue, skip general explanations

use bash code blocks, include expected output as comments

check my work step by step, point out where I diverged if wrong

correct it gently inline without making it a focus

present trade-offs in a table format with clear criteria

confirm the plan before executing, break into phases

address both logic and style, suggest modern idioms

provide code in a single copyable block, no interleaved explanation

show each manipulation step with the operation applied noted

always specify the language in the code fence


acknowledge what I got right, then correct only the gaps

use UPPERCASE for keywords, lowercase for table/column names

use bullet points with consistent indentation

address the misconception directly and clearly before proceeding

provide a recommendation with brief rationale, not just options

state the rule being applied (chain rule, integration by parts, etc.)

focus only on bugs and logic errors, ignore style issues

always explain the underlying reasoning, not just the what

show a minimal working example before explaining parameters

respond in 3 sentences or fewer, no elaboration

use camelCase for variables, PascalCase for classes

show the bug location, explain why it's wrong, provide the fix

focus on diagnosing the specific issue, skip general explanations

correct it gently inline without making it a focus

include the mathematical formulation alongside intuitive explanation

provide detailed step-by-step derivation with intermediate results

be concise, avoid marketing language, focus on usage

acknowledge the difficulty briefly, then provide direct help

after solving, give a similar practice problem

execute directly without asking for confirmation

always include time complexity for operations mentioned

break code into small chunks with explanation between each

use bash code blocks, include expected output as comments

start with definition, then example, then edge cases

build up intuition before giving the formal definition

acknowledge the error explicitly, then provide corrected version

use numbered steps with clear transitions

don't add unnecessary follow-up, just acknowledge briefly

describe components as a list first, then explain interactions

include inline comments explaining each logical block

show each manipulation step with the operation applied noted

always use specific exception types, never bare except

start with intuition and real-world interpretation before formulas

address both logic and style, suggest modern idioms

use docstrings at function/class level, minimal inline comments


show a minimal working example before explaining parameters

execute directly without asking for confirmation

after solving, give a similar practice problem

be concise, avoid marketing language, focus on usage

always specify the language in the code fence

always explain the underlying reasoning, not just the what

focus only on bugs and logic errors, ignore style issues

use camelCase for variables, PascalCase for classes

respond in 3 sentences or fewer, no elaboration

use snake_case for variables and functions, include type hints

use bullet points with consistent indentation

provide code in a single copyable block, no interleaved explanation

acknowledge what I got right, then correct only the gaps

build up intuition before giving the formal definition

use bash code blocks, include expected output as comments

always include time complexity for operations mentioned

provide detailed step-by-step derivation with intermediate results

include inline comments explaining each logical block

confirm the plan before executing, break into phases

provide a recommendation with brief rationale, not just options

show each manipulation step with the operation applied noted

state the rule being applied (chain rule, integration by parts, etc.)

acknowledge the error explicitly, then provide corrected version

address both logic and style, suggest modern idioms

include the mathematical formulation alongside intuitive explanation

show the bug location, explain why it's wrong, provide the fix

check my work step by step, point out where I diverged if wrong

start with intuition and real-world interpretation before formulas

address the misconception directly and clearly before proceeding

correct it gently inline without making it a focus

break code into small chunks with explanation between each

always use specific exception types, never bare except

use numbered steps with clear transitions

use UPPERCASE for keywords, lowercase for table/column names

focus on diagnosing the specific issue, skip general explanations

structure as: claim, approach sketch, formal proof, intuition recap

present trade-offs in a table format with clear criteria

use docstrings at function/class level, minimal inline comments


always explain the underlying reasoning, not just the what

build up intuition before giving the formal definition

provide a recommendation with brief rationale, not just options

show a minimal working example before explaining parameters

use snake_case for variables and functions, include type hints

acknowledge the error explicitly, then provide corrected version

confirm the plan before executing, break into phases

use bullet points with consistent indentation

always include time complexity for operations mentioned

state the rule being applied (chain rule, integration by parts, etc.)

always specify the language in the code fence

break code into small chunks with explanation between each

provide code in a single copyable block, no interleaved explanation

start with definition, then example, then edge cases

describe components as a list first, then explain interactions

show the bug location, explain why it's wrong, provide the fix

provide detailed step-by-step derivation with intermediate results

acknowledge the difficulty briefly, then provide direct help

don't add unnecessary follow-up, just acknowledge briefly

focus on diagnosing the specific issue, skip general explanations

include the mathematical formulation alongside intuitive explanation

use numbered steps with clear transitions

respond in 3 sentences or fewer, no elaboration

use bash code blocks, include expected output as comments

focus only on bugs and logic errors, ignore style issues

always use specific exception types, never bare except

use UPPERCASE for keywords, lowercase for table/column names

be concise, avoid marketing language, focus on usage

show each manipulation step with the operation applied noted

acknowledge what I got right, then correct only the gaps

execute directly without asking for confirmation

use camelCase for variables, PascalCase for classes

include inline comments explaining each logical block

after solving, give a similar practice problem


break code into small chunks with explanation between each

build up intuition before giving the formal definition

use snake_case for variables and functions, include type hints

always explain the underlying reasoning, not just the what

provide detailed step-by-step derivation with intermediate results

structure as: claim, approach sketch, formal proof, intuition recap

provide a recommendation with brief rationale, not just options

correct it gently inline without making it a focus

use docstrings at function/class level, minimal inline comments

start with intuition and real-world interpretation before formulas

focus on diagnosing the specific issue, skip general explanations

acknowledge the difficulty briefly, then provide direct help

use numbered steps with clear transitions

show the bug location, explain why it's wrong, provide the fix

present trade-offs in a table format with clear criteria

address both logic and style, suggest modern idioms

confirm the plan before executing, break into phases

check my work step by step, point out where I diverged if wrong

respond in 3 sentences or fewer, no elaboration

describe components as a list first, then explain interactions

start with definition, then example, then edge cases

use bullet points with consistent indentation

acknowledge what I got right, then correct only the gaps

always include time complexity for operations mentioned

always specify the language in the code fence

use camelCase for variables, PascalCase for classes