Step-by-Step Instruction Prompting

# Review the application in a controlled sequence
Step 1: Identify the application architecture.
Step 2: List all visible functional issues.
Step 3: Check the code related to each issue.
Step 4: Explain the root cause of each issue.
Step 5: Suggest the smallest safe correction.
Step 6: Verify that the correction does not break another feature.
Step 7: Present the final changes file by file.

# Define the task
Goal: Analyse the provided customer feedback and identify the main product problems.
# Define the input
Input: Customer feedback records provided below.
# Define the process
Step 1: Read all feedback records.
Step 2: Remove duplicate feedback.
Step 3: Group similar complaints into categories.
Step 4: Count the complaints in each category.
Step 5: Rank the categories from highest to lowest frequency.
Step 6: Select the three most common problems.
Step 7: Verify that every selected problem is supported by the feedback.
# Define the output
Output: Present the result as a Markdown table.
# Define the columns
Columns: Rank, problem, complaint count, example feedback, suggested action.
# Define a constraint
Constraint: Do not invent complaints that are not present in the input.

# Analyse before making changes
Step 1: Read the complete code.
Step 2: Explain what the code is intended to do.
Step 3: Identify correctness, performance, and security issues.
Step 4: Rank the issues by severity.
Step 5: Correct the highest-priority issues.
Step 6: Verify that the corrected code still satisfies the original requirement.
Step 7: Present the corrected code.
Step 8: Summarise the changes.

Step 1: Extract all product names from the input.
Step 2: Extract the price of each product.
Step 3: Remove products with missing prices.
Step 4: Sort the remaining products from lowest to highest price.
Step 5: Select the five lowest-priced products.
Step 6: Present the selected products in a table.

Step 1: Read the complete document.
Step 2: Summarise the main argument.
Step 3: Identify factual, grammatical, and structural issues.
Step 4: Correct the identified issues.
Step 5: Prepare the final report.

# Process support tickets one action at a time
Step 1: Read each support ticket.
Step 2: Identify the main issue in each ticket.
Step 3: Assign one category to each issue.
Step 4: Assign a priority level.
Step 5: Suggest the next support action.
Step 6: Present the processed tickets in a table.

Step 1: Extract the monthly revenue values.
Step 2: Use the values from Step 1 to calculate total revenue.
Step 3: Use the total from Step 2 to calculate the average monthly revenue.
Step 4: Compare each month with the average from Step 3.
Step 5: Identify months that performed below average.

Step 1: Analyse the sales data and identify measurable trends.
Step 2: Verify each trend using at least two data points.
Step 3: Create recommendations only from the verified trends in Step 2.
Step 4: Do not include recommendations that are unsupported by the data.

Step 1: Check whether the input contains a customer email address.
Step 2: If the email address is present, validate its format.
Step 3: If the email address is missing, mark the record as incomplete.
Step 4: If the format is invalid, mark the record as invalid.
Step 5: If the format is valid, mark the record as accepted.

# Evaluate the score using defined decision rules
Step 1: Read the score.
Step 2: Check whether the score is present.
Step 3: If the score is missing, return Incomplete.
Step 4: If the score is 80 or higher, return Excellent.
Step 5: If the score is between 60 and 79, return Satisfactory.
Step 6: If the score is below 60, return Needs Improvement.
Step 7: Return only one classification.

Step 1: Check whether the code contains database operations.
Step 2: If database operations are present, review the code for SQL injection risks.
Step 3: If user input is inserted directly into a query, recommend parameterised queries.
Step 4: If no database operations are present, skip the database security review.
Step 5: Continue with the general code-quality review.

Step 1: Identify the intended audience.
Step 2: If the audience is beginner-level, replace advanced terms with simple explanations.
Step 3: If the audience is technical, retain standard technical terminology.
Step 4: If the audience is not defined, use language suitable for a general professional audience.
Step 5: Preserve the original meaning in every case.

Step 1: Check whether all required input fields are available.
Step 2: If all required fields are available, continue with the analysis.
Step 3: If one or more required fields are missing, list the missing fields.
Step 4: Do not invent values for missing fields.
Step 5: Complete only the parts that can be supported by the available input.

Step 1: Generate the result.
Step 2: Compare the result with every requirement.
Step 3: Identify missing or incorrect parts.
Step 4: Correct the identified problems.
Step 5: Perform a final verification.
Step 6: Return the result only after verification is complete.

Step 1: Extract the invoice number, date, customer name, and total amount.
Step 2: Verify that every extracted value appears in the original invoice.
Step 3: Check that the date follows the YYYY-MM-DD format.
Step 4: Check that the total amount is numeric.
Step 5: Use null for fields that are not available.
Step 6: Do not guess missing values.

# Review and verify the generated function
Step 1: Write a Python function that calculates the factorial of a non-negative integer.
Step 2: Check the behaviour for input 0.
Step 3: Check the behaviour for input 1.
Step 4: Check the behaviour for a positive integer.
Step 5: Check the behaviour for a negative integer.
Step 6: Add input validation if any test fails.
Step 7: Return the final function and a short test summary.

Step 1: Extract the user's requirements.
Intermediate Result 1: Present the requirements as a numbered list.
Step 2: Convert the requirements into evaluation criteria.
Intermediate Result 2: Present the criteria and their importance.
Step 3: Compare each available option against the criteria.
Intermediate Result 3: Present the comparison in a table.
Step 4: Calculate a score for each option.
Intermediate Result 4: Present the score calculation.
Step 5: Recommend the highest-scoring option.
Final Result: Provide the recommendation with a concise justification.

Perform the required intermediate analysis internally.
Do not provide hidden reasoning or private internal notes.
Show only the extracted facts, calculations, verification results, and final conclusion.

Step 1: Search the provided text for duplicate sentences.
Step 2: Remove one duplicate at a time.
Step 3: Verify the text after each removal.
Step 4: Repeat until no duplicate sentences remain.
Stop Condition: Stop when a complete scan finds no duplicate sentences.

Step 1: Validate the JSON output.
Step 2: If the JSON is valid, return it and stop.
Step 3: If the JSON is invalid, correct the formatting.
Step 4: Validate the corrected JSON.
Step 5: Repeat the correction process a maximum of two times.
Stop Condition: Stop after successful validation or after two failed correction attempts.
Failure Output: If validation still fails, explain which requirement could not be satisfied.

Step 1: Rank the products by total score.
Step 2: Select products from the highest score downward.
Step 3: Stop after three valid products have been selected.
Step 4: Do not include additional products.

Step 1: Attempt the required action.
Step 2: Check whether the action succeeded.
Step 3: If it succeeded, continue to the next step.
Step 4: If it failed, identify the cause.
Step 5: Apply the defined recovery action.
Step 6: Retry only when retrying is safe.
Step 7: Stop and report the issue if recovery fails.

Step 1: Check for product name, price, category, and stock quantity.
Step 2: If all fields are available, process the product normally.
Step 3: If optional fields are missing, use null.
Step 4: If the product name or price is missing, mark the record as invalid.
Step 5: Do not invent missing values.
Step 6: Continue processing the remaining valid records.
Step 7: Report the number of invalid records at the end.

Step 1: Review all output requirements.
Step 2: Identify instructions that conflict with each other.
Step 3: Follow the instruction with the higher stated priority.
Step 4: If no priority is defined, choose the interpretation that best matches the main task.
Step 5: State the assumption briefly.
Step 6: Continue without inventing additional requirements.

# Generate and validate the implementation
Step 1: Generate the Java method.
Step 2: Review the code for syntax errors.
Step 3: If a syntax error is found, correct it.
Step 4: Check the corrected method against the required input and output.
Step 5: If the requirement is still not satisfied, revise the algorithm once.
Step 6: If the issue remains unresolved, report the exact limitation.
Step 7: Do not claim that the code works when verification is incomplete.

# Create the article
Step 1: Read the topic and audience requirements.
Step 2: Create an outline covering every required section.
Step 3: Write the article using simple technical language.
Step 4: Add one practical example to each major concept.
Step 5: Review the article using the checklist below.
# Verification checklist
Check 1: Every requested topic is included.
Check 2: Every heading matches its content.
Check 3: No section repeats the same explanation.
Check 4: Technical terms are explained in simple language.
Check 5: Examples are directly related to the topic.
Check 6: The article uses valid Markdown.
Step 6: Correct every failed checklist item.
Step 7: Return the final article.

# Implementation checklist
Check 1: The code matches the requested programming language.
Check 2: The method name matches the requirement.
Check 3: Input validation is included.
Check 4: Edge cases are handled.
Check 5: The algorithm is logically correct.
Check 6: The code does not contain unnecessary dependencies.
Check 7: The example output matches the code.
Check 8: The explanation matches the final implementation.

# Data analysis checklist
Check 1: Missing values are identified.
Check 2: Duplicate records are identified.
Check 3: Calculations use the correct columns.
Check 4: Units are consistent.
Check 5: Comparisons use the same time period.
Check 6: Conclusions are supported by the data.
Check 7: Limitations are stated.
Check 8: The final table contains all required fields.

Solve the problem carefully.
Provide the final answer.
Show the important calculation steps.
List the assumptions used.
Explain the selected method in five concise points.
Include a verification check.
Do not provide private hidden reasoning or unnecessary internal notes.

Step 1: Identify the formula required.
Step 2: Substitute the provided values into the formula.
Step 3: Show the calculation.
Step 4: Verify the unit.
Step 5: Provide the final answer.
Step 6: Explain the result in one sentence.

Step 1: Define the decision criteria.
Step 2: Compare each option using the criteria.
Step 3: Present the comparison in a table.
Step 4: Select the strongest option.
Step 5: Provide a concise justification based on the table.
Step 6: State one important limitation.

Step 1: Classify the support ticket as Low, Medium, or High priority.
Step 2: Apply the provided priority rules.
Step 3: Return the selected priority.
Step 4: Provide a one-sentence justification mentioning the exact rule that was triggered.

Step 1: Compare the three hosting plans.
Step 2: Evaluate price, storage, traffic capacity, backup support, and scalability.
Step 3: Recommend one plan.
Step 4: Provide exactly three justification points.
Step 5: Each point must reference one evaluation criterion.
Step 6: Do not repeat the feature list.

Step 1: Determine whether the function is correct.
Step 2: Identify the most important defect.
Step 3: Return Correct or Incorrect.
Step 4: Provide a maximum two-sentence justification.
Step 5: Mention the input that causes the failure.

# Define the writing goal
Goal: Write a beginner-friendly article about Java exception handling.
# Define the process
Step 1: Define exception handling in simple language.
Step 2: Explain why exception handling is required.
Step 3: Explain try, catch, finally, throw, and throws.
Step 4: Add one Java example for each main concept.
Step 5: Explain each example in simple points.
Step 6: Add common mistakes.
Step 7: Add best practices.
Step 8: Add a short summary.
# Verification
Step 9: Verify that every requested keyword is explained.
Step 10: Remove repeated explanations.
# Output rules
Output Format: Markdown.
Audience: Beginners.
Constraint: Do not use unnecessary advanced terminology.

# Define the requirement
Goal: Create a Java method that finds duplicate values in an integer array.
# Define the implementation steps
Step 1: Validate that the input array is not null.
Step 2: Select an efficient data structure.
Step 3: Iterate through the array once.
Step 4: Store previously seen values.
Step 5: Add repeated values to a duplicate collection.
Step 6: Prevent the same duplicate from appearing multiple times.
Step 7: Return the duplicate values.
# Verification
Step 8: Test the method with an empty array.
Step 9: Test the method with no duplicates.
Step 10: Test the method with repeated duplicates.
Step 11: Verify the time and space complexity.
# Output
Output 1: Final Java code.
Output 2: Example input and output.
Output 3: Concise complexity explanation.
Constraint: Do not use external libraries.

import java.util.HashSet;
import java.util.Set;
public class DuplicateFinder {
    public static Set<Integer> findDuplicates(int[] numbers) {
        // Reject a null input before processing
        if (numbers == null) {
            throw new IllegalArgumentException("Input array cannot be null");
        }
        Set<Integer> seen = new HashSet<>();
        Set<Integer> duplicates = new HashSet<>();
        for (int number : numbers) {
            if (!seen.add(number)) {
                duplicates.add(number);
            }
        }
        return duplicates;
    }
    public static void main(String[] args) {
        int[] numbers = {1, 2, 3, 2, 4, 1, 2};
        System.out.println(findDuplicates(numbers));
    }
}

# Define the goal
Goal: Analyse a CSV file containing monthly sales records.
# Define the data-cleaning process
Step 1: Load the CSV file.
Step 2: Verify that date, product, quantity, and revenue columns exist.
Step 3: Convert the date column to a valid date format.
Step 4: Convert quantity and revenue to numeric values.
Step 5: Remove exact duplicate records.
Step 6: Report records containing invalid required values.
# Define the analysis process
Step 7: Calculate total revenue by month.
Step 8: Calculate total revenue by product.
Step 9: Identify the highest-revenue month.
Step 10: Identify the three highest-revenue products.
# Verification
Step 11: Verify that grouped revenue totals match the cleaned dataset total.
Step 12: Report any difference.
# Output
Output 1: Cleaning summary.
Output 2: Monthly revenue table.
Output 3: Top-product table.
Output 4: Concise findings.
Constraint: Do not silently replace invalid values.

import pandas as pd
def analyse_sales(file_path):
    # Load the sales data
    data = pd.read_csv(file_path)
    required_columns = {"date", "product", "quantity", "revenue"}
    missing_columns = required_columns.difference(data.columns)
    if missing_columns:
        raise ValueError(f"Missing columns: {sorted(missing_columns)}")
    data["date"] = pd.to_datetime(data["date"], errors="coerce")
    data["quantity"] = pd.to_numeric(data["quantity"], errors="coerce")
    data["revenue"] = pd.to_numeric(data["revenue"], errors="coerce")
    data = data.drop_duplicates()
    invalid_rows = data[data[list(required_columns)].isnull().any(axis=1)]
    clean_data = data.dropna(subset=list(required_columns))
    clean_data["month"] = clean_data["date"].dt.to_period("M").astype(str)
    monthly_revenue = clean_data.groupby("month", as_index=False)["revenue"].sum()
    product_revenue = clean_data.groupby("product", as_index=False)["revenue"].sum()
    product_revenue = product_revenue.sort_values("revenue", ascending=False)
    return {
        "invalid_rows": invalid_rows,
        "monthly_revenue": monthly_revenue,
        "top_products": product_revenue.head(3)
    }

# Define the goal
Goal: Write an SQL query that finds the five customers with the highest total order value.
# Define the database structure
Table 1: customers with customer_id and customer_name.
Table 2: orders with order_id, customer_id, order_total, and order_status.
# Define the query steps
Step 1: Join customers and orders using customer_id.
Step 2: Include only orders with order_status equal to Completed.
Step 3: Group records by customer ID and customer name.
Step 4: Calculate the total completed order value for each customer.
Step 5: Sort customers by total order value in descending order.
Step 6: Return only the first five customers.
# Verification
Step 7: Ensure customers are not duplicated in the final result.
Step 8: Ensure cancelled orders are excluded.
# Output
Output 1: SQL query.
Output 2: Two-sentence explanation.
Constraint: Use standard SQL where possible.

SELECT
    c.customer_id,
    c.customer_name,
    SUM(o.order_total) AS total_order_value
FROM customers c
INNER JOIN orders o ON o.customer_id = c.customer_id
WHERE o.order_status = 'Completed'
GROUP BY c.customer_id, c.customer_name
ORDER BY total_order_value DESC
FETCH FIRST 5 ROWS ONLY;

# Define the problem
Problem: A Spring Boot API returns HTTP 500 when a user record is not found.
# Define the debugging process
Step 1: Identify the controller method handling the request.
Step 2: Identify the service method used by the controller.
Step 3: Check how the repository handles a missing record.
Step 4: Identify the exception currently produced.
Step 5: Determine the correct HTTP status for a missing resource.
Step 6: Add or update the custom exception.
Step 7: Add global exception handling.
Step 8: Return a structured error response.
# Verification
Step 9: Verify the response for an existing user.
Step 10: Verify the response for a missing user.
Step 11: Verify that unexpected exceptions still return HTTP 500.
# Output
Output 1: Root cause.
Output 2: Corrected code.
Output 3: Expected HTTP responses.
Output 4: Concise test checklist.

# Define the research question
Goal: Compare remote work and office work for software development teams.
# Define the research process
Step 1: Define the comparison criteria.
Step 2: Separate measurable factors from opinion-based factors.
Step 3: Collect evidence for productivity, communication, cost, hiring, and employee satisfaction.
Step 4: Record the date and source of each important claim.
Step 5: Compare the findings under each criterion.
Step 6: Identify areas where evidence is mixed.
Step 7: State the limitations of the comparison.
Step 8: Create a balanced conclusion.
# Verification
Step 9: Remove claims that have no reliable support.
Step 10: Verify that the conclusion matches the evidence.
# Output
Output 1: Comparison table.
Output 2: Key findings.
Output 3: Balanced conclusion.
Output 4: Source list.

# Define the task
Goal: Create a customer support response for a delayed order.
# Define the process
Step 1: Identify the customer's concern.
Step 2: Acknowledge the inconvenience.
Step 3: State the available order status.
Step 4: Explain the next action.
Step 5: Mention the expected update time only if it is known.
Step 6: Provide a support contact option.
# Conditional rule
Step 7: If the delivery date is unknown, do not invent one.
Step 8: If a refund is available, explain the refund option.
# Verification
Step 9: Check that the response is polite and direct.
Step 10: Check that no unsupported promise is included.
# Output
Output: A professional customer email under 150 words.

# Define the goal
Goal: Compare three laptops for a software development student.
# Define the criteria
Criterion 1: Processor performance.
Criterion 2: RAM capacity.
Criterion 3: Storage.
Criterion 4: Battery life.
Criterion 5: Display quality.
Criterion 6: Upgrade options.
Criterion 7: Price.
# Define the process
Step 1: Extract the specification of each laptop.
Step 2: Mark any unavailable specification as Not Available.
Step 3: Compare all laptops using the same criteria.
Step 4: Identify the strongest option for coding.
Step 5: Identify the strongest option for battery life.
Step 6: Identify the best value option.
Step 7: Recommend one laptop based on the user's main requirement.
# Verification
Step 8: Ensure the recommendation is supported by the comparison.
# Output
Output 1: Comparison table.
Output 2: Category winners.
Output 3: Final recommendation with three justification points.

# Define the goal
Goal: Localise the provided English product description for Indian users.
# Define the process
Step 1: Identify the original meaning and main selling points.
Step 2: Preserve product names and technical specifications.
Step 3: Replace unfamiliar cultural references with suitable Indian references.
Step 4: Use Indian English spelling and usage.
Step 5: Use rupees for price examples when conversion information is provided.
Step 6: Preserve the original professional tone.
Step 7: Avoid word-for-word translation when it sounds unnatural.
# Verification
Step 8: Compare the localised version with the original meaning.
Step 9: Verify that no product claim was added or removed.
# Output
Output 1: Localised description.
Output 2: Short list of major localisation changes.

# Define the goal
Goal: Create a four-week plan for launching a programming tutorial website.
# Define the process
Step 1: Define the launch requirements.
Step 2: Divide the work into content, development, testing, SEO, and deployment.
Step 3: Identify dependencies between tasks.
Step 4: Estimate the effort of each task.
Step 5: Assign tasks to four weekly phases.
Step 6: Mark tasks that can run in parallel.
Step 7: Add a verification checkpoint at the end of each week.
Step 8: Identify the main launch risks.
Step 9: Define a fallback action for each high-priority risk.
# Stop condition
Step 10: Stop adding tasks when every launch requirement is assigned to a week.
# Output
Output 1: Weekly plan table.
Output 2: Dependency list.
Output 3: Risk and recovery table.
Output 4: Launch-readiness checklist.

Goal: Summarise the provided article.
Step 1: Read the complete article.
Step 2: Identify the main topic.
Step 3: Identify the five most important points.
Step 4: Remove repeated information.
Step 5: Write a summary of 150 words.
Step 6: Verify that the summary does not add new facts.
Output Format: One paragraph followed by five bullet points.

Goal: Review the provided API design.
Step 1: Identify every endpoint.
Step 2: Record the method, path, request body, response body, and status codes.
Step 3: Check endpoint naming consistency.
Step 4: Check whether HTTP methods match the intended operations.
Step 5: Check whether success and error responses are defined.
Step 6: If authentication is required, verify that the authentication requirement is documented.
Step 7: If pagination is required, verify that pagination parameters and metadata are defined.
Step 8: List all identified issues.
Step 9: Rank the issues as Critical, High, Medium, or Low.
Step 10: Suggest one correction for each issue.
Step 11: Verify that each suggestion matches the original API purpose.
Output Format: Summary followed by an issue table.

# Define the objective
Goal: Analyse application logs and identify the most likely cause of a production failure.
# Define the first stage
Step 1: Extract timestamps, service names, request IDs, error levels, exception names, and messages.
Intermediate Result 1: Structured event list.
# Define the second stage
Step 2: Sort events by timestamp.
Step 3: Group events by request ID.
Intermediate Result 2: Request-level timelines.
# Define the third stage
Step 4: Identify the first error in each failed request.
Step 5: Separate primary errors from secondary errors.
Intermediate Result 3: Candidate root causes.
# Define decision rules
Step 6: If the same primary error appears across multiple requests, mark it as a repeated failure pattern.
Step 7: If an error appears only after another failure, mark it as a possible secondary effect.
Step 8: If required log details are missing, state which evidence is unavailable.
# Define verification
Step 9: Compare each candidate cause with the complete event timeline.
Step 10: Remove candidates that conflict with the timeline.
Step 11: Rank the remaining candidates by evidence strength.
# Define recovery
Step 12: If no candidate has enough evidence, return Insufficient Evidence.
Step 13: Recommend the additional logs or metrics required.
# Define the stop condition
Stop Condition: Stop after one root cause is strongly supported or after available evidence is exhausted.
# Define the output
Output 1: Incident timeline.
Output 2: Most likely root cause.
Output 3: Supporting evidence.
Output 4: Confidence level.
Output 5: Recommended corrective action.
Output 6: Missing evidence and limitations.

Step 1: Remove invalid and duplicate records.
Step 2: Use the cleaned records to calculate the average.

Step 1: Locate the invoice total.
Step 2: If the total is present, extract it.
Step 3: If the total is not present, return null.
Step 4: Do not calculate or guess the missing total.

# Define the role
Role: Act as a [role or subject expert].
# Define the objective
Goal: [Describe the final result].
# Define the context
Context: [Provide relevant background information].
# Define the input
Input: [Provide or describe the input data].
# Define the ordered process
Step 1: [Perform the first action].
Step 2: [Perform the second action].
Step 3: [Use the result from Step 2 to perform the next action].
Step 4: [Apply a decision rule].
Step 5: [Create an intermediate result].
Step 6: [Verify the intermediate result].
Step 7: [Correct any identified issue].
Step 8: [Generate the final result].
# Define conditional rules
Condition 1: If [condition], then [action].
Condition 2: If [condition], then [action].
Fallback Condition: If no defined condition applies, [fallback action].
# Define error recovery
Error Rule 1: If required input is missing, [recovery action].
Error Rule 2: If validation fails, [recovery action].
Retry Limit: [Maximum number of retries].
# Define the stop condition
Stop Condition: Stop when [measurable completion condition].
# Define verification
Verification 1: Check [requirement].
Verification 2: Check [requirement].
Verification 3: Check [requirement].
# Define the output
Output Format: [Markdown, table, JSON, code, report, or another format].
Required Fields: [List required output fields].
Explanation Length: [Define explanation limit].
# Define constraints
Constraint 1: Do not [prohibited action].
Constraint 2: Use only [allowed information].
Constraint 3: State missing information instead of guessing.
# Define justification
Justification: Provide [number] concise reasons based on [evidence or criteria].

Goal: [Define the result].
Step 1: [First action].
Step 2: [Second action].
Step 3: [Third action].
Step 4: Verify [important requirement].
Step 5: Correct any failed verification.
Stop Condition: Stop when [completion condition].
Error Rule: If [error condition], [recovery action].
Output: [Required output format].
Constraint: [Important restriction].
Justification: Explain the result in [defined length].