15 ready-to-use ChatGPT prompts for robotics and automation. Fill in the bracketed fields, paste into ChatGPT, and go.
Engineering · 15 prompts
01
Design a Precision Control Algorithm for a Robotic Arm
Design a control algorithm for moving an object precisely with a robotic arm.
You’ll needarm degrees of freedomtask precisioncontrol constraintsenvironment
Prompt
You are a senior robotics and automation architect creating a plan for a real engineering initiative.
Create a plan for the task below.
Context:
- Goal: [goal]
- Stack or environment: [stack]
- Current system or baseline: [current system]
- Constraints such as security, latency, budget, or staffing: [constraints]
- Scale, complexity, or production expectations: [scale]
- Risks, current issues, or dependencies: [risks]
Instructions:
1. Recommend a practical technical approach and explain why it fits the context.
2. Break the work into sensible phases, components, or rollout stages.
3. Explicitly address the failure modes that actually derail this kind of initiative: control tuned for a nominal payload that becomes unstable or imprecise when the actual payload mass or inertia differs, no plan for handling a commanded position outside the arm's reachable workspace, positional accuracy validated only in simulation with no plan to account for real backlash, compliance, or sensor noise, and no safe-stop behavior defined for when the arm encounters unexpected resistance mid-motion.
4. Include validation, rollback, migration, or monitoring considerations where relevant.
5. Keep the plan realistic for the stated context and avoid architecture theater.
Output format:
- Plan overview
- Recommended approach and tradeoffs
- Implementation phases or rollout path
- Risks, dependencies, and validation checks
- Main assumptions or open questions
Missing information policy:
Ask up to 2 concise questions only if the goal or environment is unclear. Otherwise proceed with assumptions.
Quality bar:
- Make the plan executable.
- Avoid overengineering.
- Name the specific failure modes above rather than generic risk language.
- Show how the plan would survive real deployment pressure.
02
Develop an RPA Simulation Model
Develop a simulation model for a robotic process automation workflow that handles repetitive tasks.
You are a senior robotics and automation architect creating a plan for a real engineering initiative.
Create a plan for the task below.
Context:
- Goal: [goal]
- Stack or environment: [stack]
- Current system or baseline: [current system]
- Constraints such as security, latency, budget, or staffing: [constraints]
- Scale, complexity, or production expectations: [scale]
- Risks, current issues, or dependencies: [risks]
Instructions:
1. Recommend a practical technical approach and explain why it fits the context.
2. Break the work into sensible phases, components, or rollout stages.
3. Explicitly address the failure modes that actually derail this kind of initiative: the simulation modeling the happy-path workflow only and not exception cases like a missing field, an unexpected popup, or a slow-loading page that break real RPA bots in production, no plan for what happens when the underlying UI or system the bot depends on changes layout, bot execution treated as instantaneous with no timing or race-condition modeling against real system latency, and no human-escalation path modeled for when the bot can't complete a step.
4. Include validation, rollback, migration, or monitoring considerations where relevant.
5. Keep the plan realistic for the stated context and avoid architecture theater.
Output format:
- Plan overview
- Recommended approach and tradeoffs
- Implementation phases or rollout path
- Risks, dependencies, and validation checks
- Main assumptions or open questions
Missing information policy:
Ask up to 2 concise questions only if the goal or environment is unclear. Otherwise proceed with assumptions.
Quality bar:
- Make the plan executable.
- Avoid overengineering.
- Name the specific failure modes above rather than generic risk language.
- Show how the plan would survive real deployment pressure.
03
Write a Program for Autonomous Drone Movement
Write a program to control a drone autonomously along a predefined path.
You are a senior robotics and automation engineer.
Produce code or a code scaffold for an autonomous drone path-following program.
Context:
- Goal or feature: [goal]
- Stack or language: [stack]
- Inputs and outputs: [inputs and outputs]
- Constraints: [constraints]
- Existing code context: [existing context]
- Integration points or surrounding system: [integration points]
- Acceptance criteria or edge cases: [acceptance criteria]
Instructions:
1. Make the key implementation decisions first, then write code that is correct, readable, and idiomatic for the stated stack.
2. Default to realistic production patterns for common tasks instead of toy scaffolds.
3. Include only the structure that materially helps maintainability, testing, or integration.
4. Explicitly address the failure modes that actually break this in production: no GPS-loss or degraded-signal fallback behavior, so the drone continues on stale position estimates as if they were current, geofence or no-fly-zone boundaries not enforced in software as a hard limit and only assumed via planning, battery-remaining not factored into the path so a return-to-home command can be issued too late to actually make it back, and no failsafe for a lost communication link beyond continuing the last command.
5. Include validation guidance such as test cases, failure modes, or manual verification steps.
6. Avoid filler placeholders, fake environment variables, and pseudo-code unless the user explicitly wants a sketch.
Output format:
- Implementation approach
- Code
- Validation and test cases (including GPS-loss and low-battery scenarios)
- Integration notes and assumptions
Missing information policy:
Ask up to 2 concise questions only if the language, framework, integration point, or required behavior is unclear. Otherwise proceed with assumptions.
Quality bar:
- Prefer working simplicity with production realism.
- Avoid placeholder-heavy pseudo-code unless necessary.
- Name the specific failure modes above rather than generic edge-case language.
- Cover meaningful edge cases instead of only the happy path.
04
Create an Industrial Robot Test Automation System
Create a system to automate testing of industrial robot performance on a production line.
You are a senior robotics and automation architect creating a plan for a real engineering initiative.
Create a plan for the task below.
Context:
- Goal: [goal]
- Stack or environment: [stack]
- Current system or baseline: [current system]
- Constraints such as security, latency, budget, or staffing: [constraints]
- Scale, complexity, or production expectations: [scale]
- Risks, current issues, or dependencies: [risks]
Instructions:
1. Recommend a practical technical approach and explain why it fits the context.
2. Break the work into sensible phases, components, or rollout stages.
3. Explicitly address the failure modes that actually derail this kind of initiative: test automation that only validates nominal-speed operation and skips the edge of the robot's rated performance envelope, no plan for testing behavior under a simulated sensor or actuator fault, test results not tied back to the specific production tolerance the robot needs to hit, and no safety-interlock verification built into the automated test sequence itself.
4. Include validation, rollback, migration, or monitoring considerations where relevant.
5. Keep the plan realistic for the stated context and avoid architecture theater.
Output format:
- Plan overview
- Recommended approach and tradeoffs
- Implementation phases or rollout path
- Risks, dependencies, and validation checks
- Main assumptions or open questions
Missing information policy:
Ask up to 2 concise questions only if the goal or environment is unclear. Otherwise proceed with assumptions.
Quality bar:
- Make the plan executable.
- Avoid overengineering.
- Name the specific failure modes above rather than generic risk language.
- Show how the plan would survive real deployment pressure.
05
Design a Human-Robot Safety Protocol
Design a safety protocol for human-robot interaction in a factory setting.
You are a senior robotics and automation architect creating a plan for a real engineering initiative.
Create a plan for the task below.
Context:
- Goal: [goal]
- Stack or environment: [stack]
- Current system or baseline: [current system]
- Constraints such as security, latency, budget, or staffing: [constraints]
- Scale, complexity, or production expectations: [scale]
- Risks, current issues, or dependencies: [risks]
Instructions:
1. Recommend a practical technical approach and explain why it fits the context.
2. Break the work into sensible phases, components, or rollout stages.
3. Explicitly address the failure modes that actually derail this kind of initiative: safety zones defined statically with no accounting for the robot's actual stopping distance at full speed, emergency-stop response verified once in testing but not re-verified after any mechanical or software change, no protocol for degraded-sensor operation when a safety-relevant sensor goes offline beyond assuming it always works, and human proximity detection that has blind spots the protocol doesn't account for.
4. Include validation, rollback, migration, or monitoring considerations where relevant.
5. Keep the plan realistic for the stated context and avoid architecture theater.
Output format:
- Plan overview
- Recommended approach and tradeoffs
- Implementation phases or rollout path
- Risks, dependencies, and validation checks
- Main assumptions or open questions
Missing information policy:
Ask up to 2 concise questions only if the goal or environment is unclear. Otherwise proceed with assumptions.
Quality bar:
- Make the plan executable.
- Avoid overengineering.
- Name the specific failure modes above rather than generic risk language.
- Show how the plan would survive real deployment pressure.
06
Improve Robot Decision-Making with Machine Learning
Develop a machine learning model to improve robot decisions in an unpredictable environment.
You are a senior robotics and automation architect creating a plan for a real engineering initiative.
Create a plan for the task below.
Context:
- Goal: [goal]
- Stack or environment: [stack]
- Current system or baseline: [current system]
- Constraints such as security, latency, budget, or staffing: [constraints]
- Scale, complexity, or production expectations: [scale]
- Risks, current issues, or dependencies: [risks]
Instructions:
1. Recommend a practical technical approach and explain why it fits the context.
2. Break the work into sensible phases, components, or rollout stages.
3. Explicitly address the failure modes that actually derail this kind of initiative: the model trained in simulation with no plan for the sim-to-real gap that makes real-world decisions diverge from training performance, a reward or objective function that optimizes a proxy metric instead of the actual safety or task outcome that matters, no fallback to a deterministic safe behavior when the model's confidence is low, and no monitoring plan for model decisions drifting as the real environment changes from what was trained on.
4. Include validation, rollback, migration, or monitoring considerations where relevant.
5. Keep the plan realistic for the stated context and avoid architecture theater.
Output format:
- Plan overview
- Recommended approach and tradeoffs
- Implementation phases or rollout path
- Risks, dependencies, and validation checks
- Main assumptions or open questions
Missing information policy:
Ask up to 2 concise questions only if the goal or environment is unclear. Otherwise proceed with assumptions.
Quality bar:
- Make the plan executable.
- Avoid overengineering.
- Name the specific failure modes above rather than generic risk language.
- Show how the plan would survive real deployment pressure.
07
Write a Robotic Sensor Calibration Script
Write an automation script for calibrating robotic sensors accurately.
You are a senior robotics and automation engineer.
Produce code or a code scaffold for a robotic sensor calibration script.
Context:
- Goal or feature: [goal]
- Stack or language: [stack]
- Inputs and outputs: [inputs and outputs]
- Constraints: [constraints]
- Existing code context: [existing context]
- Integration points or surrounding system: [integration points]
- Acceptance criteria or edge cases: [acceptance criteria]
Instructions:
1. Make the key implementation decisions first, then write code that is correct, readable, and idiomatic for the stated stack.
2. Default to realistic production patterns for common tasks instead of toy scaffolds.
3. Include only the structure that materially helps maintainability, testing, or integration.
4. Explicitly address the failure modes that actually break this in production: calibration performed once at startup with no drift compensation over time or temperature, a routine that silently accepts an obviously bad reading such as a disconnected sensor as a valid zero point, no versioning of calibration parameters so a bad calibration can't be rolled back to the last known-good set, and a procedure that assumes a single reference condition instead of validating across the sensor's actual operating range.
5. Include validation guidance such as test cases, failure modes, or manual verification steps.
6. Avoid filler placeholders, fake environment variables, and pseudo-code unless the user explicitly wants a sketch.
Output format:
- Implementation approach
- Code
- Validation and test cases (including bad-reading rejection)
- Integration notes and assumptions
Missing information policy:
Ask up to 2 concise questions only if the language, framework, integration point, or required behavior is unclear. Otherwise proceed with assumptions.
Quality bar:
- Prefer working simplicity with production realism.
- Avoid placeholder-heavy pseudo-code unless necessary.
- Name the specific failure modes above rather than generic edge-case language.
- Cover meaningful edge cases instead of only the happy path.
08
Create a Maze-Navigating Robot Program
Create a program for a robot to navigate a maze with a pathfinding algorithm like A*.
You are a senior robotics and automation engineer.
Produce code or a code scaffold for a maze-navigating robot program with pathfinding.
Context:
- Goal or feature: [goal]
- Stack or language: [stack]
- Inputs and outputs: [inputs and outputs]
- Constraints: [constraints]
- Existing code context: [existing context]
- Integration points or surrounding system: [integration points]
- Acceptance criteria or edge cases: [acceptance criteria]
Instructions:
1. Make the key implementation decisions first, then write code that is correct, readable, and idiomatic for the stated stack.
2. Default to realistic production patterns for common tasks instead of toy scaffolds.
3. Include only the structure that materially helps maintainability, testing, or integration.
4. Explicitly address the failure modes that actually break this in production: pathfinding implemented against a static map with no replanning when an unexpected obstacle appears, tie-breaking in the heuristic left undefined and producing inconsistent paths between runs on the same maze, no handling for the robot's actual turning radius or footprint so a mathematically valid path is physically impossible to execute, and no timeout or deadlock recovery if the robot's actual position drifts from the planned path.
5. Include validation guidance such as test cases, failure modes, or manual verification steps.
6. Avoid filler placeholders, fake environment variables, and pseudo-code unless the user explicitly wants a sketch.
Output format:
- Implementation approach
- Code
- Validation and test cases (including replanning and drift recovery)
- Integration notes and assumptions
Missing information policy:
Ask up to 2 concise questions only if the language, framework, integration point, or required behavior is unclear. Otherwise proceed with assumptions.
Quality bar:
- Prefer working simplicity with production realism.
- Avoid placeholder-heavy pseudo-code unless necessary.
- Name the specific failure modes above rather than generic edge-case language.
- Cover meaningful edge cases instead of only the happy path.
09
Monitor Robotic Equipment Health
Develop a system to monitor robotic equipment health and trigger maintenance alerts.
You are a senior robotics and automation architect creating a plan for a real engineering initiative.
Create a plan for the task below.
Context:
- Goal: [goal]
- Stack or environment: [stack]
- Current system or baseline: [current system]
- Constraints such as security, latency, budget, or staffing: [constraints]
- Scale, complexity, or production expectations: [scale]
- Risks, current issues, or dependencies: [risks]
Instructions:
1. Recommend a practical technical approach and explain why it fits the context.
2. Break the work into sensible phases, components, or rollout stages.
3. Explicitly address the failure modes that actually derail this kind of initiative: thresholds for triggering maintenance alerts set from generic manufacturer specs instead of this equipment's actual usage and wear pattern, no distinction between a sensor fault and an actual equipment fault, alert fatigue from too many low-confidence alerts causing real ones to be ignored, and no feedback loop from actual maintenance findings back into tuning the monitoring thresholds.
4. Include validation, rollback, migration, or monitoring considerations where relevant.
5. Keep the plan realistic for the stated context and avoid architecture theater.
Output format:
- Plan overview
- Recommended approach and tradeoffs
- Implementation phases or rollout path
- Risks, dependencies, and validation checks
- Main assumptions or open questions
Missing information policy:
Ask up to 2 concise questions only if the goal or environment is unclear. Otherwise proceed with assumptions.
Quality bar:
- Make the plan executable.
- Avoid overengineering.
- Name the specific failure modes above rather than generic risk language.
- Show how the plan would survive real deployment pressure.
10
Simulate a Robotic Arm in 3D with Inverse Kinematics
Write code to simulate robotic arm movement in 3D space using inverse kinematics.
You are a senior robotics and automation engineer.
Produce code or a code scaffold for a 3D robotic arm simulation using inverse kinematics.
Context:
- Goal or feature: [goal]
- Stack or language: [stack]
- Inputs and outputs: [inputs and outputs]
- Constraints: [constraints]
- Existing code context: [existing context]
- Integration points or surrounding system: [integration points]
- Acceptance criteria or edge cases: [acceptance criteria]
Instructions:
1. Make the key implementation decisions first, then write code that is correct, readable, and idiomatic for the stated stack.
2. Default to realistic production patterns for common tasks instead of toy scaffolds.
3. Include only the structure that materially helps maintainability, testing, or integration.
4. Explicitly address the failure modes that actually break this in production: inverse kinematics solved without checking joint limits, producing solutions the physical arm can't actually reach, singularities near fully-extended or fully-retracted poses not detected and causing erratic or undefined movement, no collision checking between the arm's own links or with the environment, and multiple valid IK solutions such as elbow-up versus elbow-down with no consistent selection rule, causing the simulated arm to flip unpredictably.
5. Include validation guidance such as test cases, failure modes, or manual verification steps.
6. Avoid filler placeholders, fake environment variables, and pseudo-code unless the user explicitly wants a sketch.
Output format:
- Implementation approach
- Code
- Validation and test cases (including joint-limit and singularity checks)
- Integration notes and assumptions
Missing information policy:
Ask up to 2 concise questions only if the language, framework, integration point, or required behavior is unclear. Otherwise proceed with assumptions.
Quality bar:
- Prefer working simplicity with production realism.
- Avoid placeholder-heavy pseudo-code unless necessary.
- Name the specific failure modes above rather than generic edge-case language.
- Cover meaningful edge cases instead of only the happy path.
11
Design a Robot Maintenance Scheduling System
Design a system for maintenance scheduling based on robot usage metrics.
You are a senior robotics and automation architect creating a plan for a real engineering initiative.
Create a plan for the task below.
Context:
- Goal: [goal]
- Stack or environment: [stack]
- Current system or baseline: [current system]
- Constraints such as security, latency, budget, or staffing: [constraints]
- Scale, complexity, or production expectations: [scale]
- Risks, current issues, or dependencies: [risks]
Instructions:
1. Recommend a practical technical approach and explain why it fits the context.
2. Break the work into sensible phases, components, or rollout stages.
3. Explicitly address the failure modes that actually derail this kind of initiative: scheduling based on calendar time instead of actual usage metrics, over- or under-maintaining equipment relative to its real wear, no accounting for production-schedule conflicts so maintenance windows get skipped or delayed under deadline pressure, parts or consumables lead time not factored into the schedule and causing a robot to sit idle waiting on a part, and no tracking of whether scheduled maintenance actually gets completed versus just planned.
4. Include validation, rollback, migration, or monitoring considerations where relevant.
5. Keep the plan realistic for the stated context and avoid architecture theater.
Output format:
- Plan overview
- Recommended approach and tradeoffs
- Implementation phases or rollout path
- Risks, dependencies, and validation checks
- Main assumptions or open questions
Missing information policy:
Ask up to 2 concise questions only if the goal or environment is unclear. Otherwise proceed with assumptions.
Quality bar:
- Make the plan executable.
- Avoid overengineering.
- Name the specific failure modes above rather than generic risk language.
- Show how the plan would survive real deployment pressure.
12
Adjust Robot Speed from Real-Time Sensor Feedback
Create a script to monitor and adjust robot speed and movement based on sensor feedback.
You are a senior robotics and automation engineer.
Produce code or a code scaffold for a real-time sensor-feedback speed-adjustment script for a robot.
Context:
- Goal or feature: [goal]
- Stack or language: [stack]
- Inputs and outputs: [inputs and outputs]
- Constraints: [constraints]
- Existing code context: [existing context]
- Integration points or surrounding system: [integration points]
- Acceptance criteria or edge cases: [acceptance criteria]
Instructions:
1. Make the key implementation decisions first, then write code that is correct, readable, and idiomatic for the stated stack.
2. Default to realistic production patterns for common tasks instead of toy scaffolds.
3. Include only the structure that materially helps maintainability, testing, or integration.
4. Explicitly address the failure modes that actually break this in production: a feedback loop with no filtering on noisy sensor input, causing jittery speed changes that stress the motor, control gains tuned for one load condition that become unstable or oscillate under a different load, no rate-limiting on how fast speed commands can change, risking mechanical shock, and no fallback behavior defined for when sensor feedback is lost or clearly invalid mid-operation.
5. Include validation guidance such as test cases, failure modes, or manual verification steps.
6. Avoid filler placeholders, fake environment variables, and pseudo-code unless the user explicitly wants a sketch.
Output format:
- Implementation approach
- Code
- Validation and test cases (including sensor-loss fallback)
- Integration notes and assumptions
Missing information policy:
Ask up to 2 concise questions only if the language, framework, integration point, or required behavior is unclear. Otherwise proceed with assumptions.
Quality bar:
- Prefer working simplicity with production realism.
- Avoid placeholder-heavy pseudo-code unless necessary.
- Name the specific failure modes above rather than generic edge-case language.
- Cover meaningful edge cases instead of only the happy path.
13
Optimize Task Allocation in a Multi-Robot System
Develop an algorithmic plan for optimizing task allocation across multiple robots.
You are a senior robotics and automation architect creating a plan for a real engineering initiative.
Create a plan for the task below.
Context:
- Goal: [goal]
- Stack or environment: [stack]
- Current system or baseline: [current system]
- Constraints such as security, latency, budget, or staffing: [constraints]
- Scale, complexity, or production expectations: [scale]
- Risks, current issues, or dependencies: [risks]
Instructions:
1. Recommend a practical technical approach and explain why it fits the context.
2. Break the work into sensible phases, components, or rollout stages.
3. Explicitly address the failure modes that actually derail this kind of initiative: allocation optimized for throughput with no accounting for collision or path-conflict risk between robots working the same physical space, no replanning when a robot fails or falls behind mid-task, static task-cost assumptions that don't reflect real variability in execution time, and no fairness or starvation check that can leave one robot's tasks perpetually deprioritized.
4. Include validation, rollback, migration, or monitoring considerations where relevant.
5. Keep the plan realistic for the stated context and avoid architecture theater.
Output format:
- Plan overview
- Recommended approach and tradeoffs
- Implementation phases or rollout path
- Risks, dependencies, and validation checks
- Main assumptions or open questions
Missing information policy:
Ask up to 2 concise questions only if the goal or environment is unclear. Otherwise proceed with assumptions.
Quality bar:
- Make the plan executable.
- Avoid overengineering.
- Name the specific failure modes above rather than generic risk language.
- Show how the plan would survive real deployment pressure.
14
Map an Environment with LiDAR and Vision Inputs
Write a program for a robot to map its environment using LiDAR and vision inputs.
You are a senior robotics and automation engineer.
Produce code or a code scaffold for a LiDAR and vision environment-mapping program for a robot.
Context:
- Goal or feature: [goal]
- Stack or language: [stack]
- Inputs and outputs: [inputs and outputs]
- Constraints: [constraints]
- Existing code context: [existing context]
- Integration points or surrounding system: [integration points]
- Acceptance criteria or edge cases: [acceptance criteria]
Instructions:
1. Make the key implementation decisions first, then write code that is correct, readable, and idiomatic for the stated stack.
2. Default to realistic production patterns for common tasks instead of toy scaffolds.
3. Include only the structure that materially helps maintainability, testing, or integration.
4. Explicitly address the failure modes that actually break this in production: no sensor-fusion strategy for reconciling LiDAR and vision data when they disagree, producing an inconsistent map, moving objects in the environment treated as static obstacles that permanently pollute the map, no loop-closure handling so accumulated drift makes the map inconsistent over a long traversal, and point-cloud data processed with no downsampling, overwhelming compute at real-world scale.
5. Include validation guidance such as test cases, failure modes, or manual verification steps.
6. Avoid filler placeholders, fake environment variables, and pseudo-code unless the user explicitly wants a sketch.
Output format:
- Implementation approach
- Code
- Validation and test cases (including loop-closure and moving-object handling)
- Integration notes and assumptions
Missing information policy:
Ask up to 2 concise questions only if the language, framework, integration point, or required behavior is unclear. Otherwise proceed with assumptions.
Quality bar:
- Prefer working simplicity with production realism.
- Avoid placeholder-heavy pseudo-code unless necessary.
- Name the specific failure modes above rather than generic edge-case language.
- Cover meaningful edge cases instead of only the happy path.
15
Design a Fault Detection System for Robotic Arms
Design a fault detection system that predicts and prevents robotic arm breakdowns.
You are a senior robotics and automation architect creating a plan for a real engineering initiative.
Create a plan for the task below.
Context:
- Goal: [goal]
- Stack or environment: [stack]
- Current system or baseline: [current system]
- Constraints such as security, latency, budget, or staffing: [constraints]
- Scale, complexity, or production expectations: [scale]
- Risks, current issues, or dependencies: [risks]
Instructions:
1. Recommend a practical technical approach and explain why it fits the context.
2. Break the work into sensible phases, components, or rollout stages.
3. Explicitly address the failure modes that actually derail this kind of initiative: detection tuned to catch failures that have already happened rather than the leading indicators that predict one, no distinction between a sensor reporting bad data and the arm actually being faulty, a false-positive rate high enough in practice that operators start ignoring alerts, and no closed loop from a detected fault back into adjusting the maintenance schedule or operating parameters.
4. Include validation, rollback, migration, or monitoring considerations where relevant.
5. Keep the plan realistic for the stated context and avoid architecture theater.
Output format:
- Plan overview
- Recommended approach and tradeoffs
- Implementation phases or rollout path
- Risks, dependencies, and validation checks
- Main assumptions or open questions
Missing information policy:
Ask up to 2 concise questions only if the goal or environment is unclear. Otherwise proceed with assumptions.
Quality bar:
- Make the plan executable.
- Avoid overengineering.
- Name the specific failure modes above rather than generic risk language.
- Show how the plan would survive real deployment pressure.