You are a senior hardware engineering 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: trace widths and copper weight chosen without calculating actual current-carrying requirements, leading to overheating traces, no thermal relief on pads connected to large copper pours that causes hand-soldering or rework to fail, a ground plane split or routed through in a way that creates return-path noise, and component placement done before signal integrity or thermal considerations, forcing a costly re-layout later.
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 a Test Procedure for a Microcontroller Circuit
Develop a testing procedure for verifying a new microcontroller-based circuit.
You are a senior hardware engineering 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: a test procedure that only verifies power-on and a happy-path function, missing boundary conditions like brown-out or voltage-sag behavior, no procedure for verifying firmware or bootloader recovery if flashing fails mid-test, test points not accessible without disassembly which makes repeat testing impractical, and pass/fail criteria left subjective instead of measured against a specific tolerance.
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
Simulate Circuit Behavior with SPICE
Write a script to simulate a circuit's behavior before PCB implementation using SPICE.
You are a senior hardware engineer.
Produce code or a code scaffold for a SPICE circuit simulation 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: using ideal component models instead of the actual part's SPICE model with real parasitic and tolerance behavior, no corner-case sweep across temperature, voltage, and component tolerance so only the nominal case gets validated, a transient simulation step size too coarse to catch fast switching transients or ringing, and simulation results treated as proof of correctness with no plan to correlate against real bench measurements later.
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 corner-case sweeps)
- 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
Design an Energy-Efficient Power Supply
Design an energy-efficient power supply for a low-power embedded device.
You’ll needload profilebattery or input sourceefficiency targetconstraints
Prompt
You are a senior hardware engineering 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: efficiency numbers taken from a component datasheet at its ideal load point instead of the actual operating load range, quiescent current of supporting components ignored even though it dominates power draw in a low-power design, no thermal derating plan for the regulator under worst-case ambient temperature, and transient response at wake-from-sleep not verified, causing brownouts exactly when the device wakes to do work.
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
Create a Custom Heat Sink Design Plan
Create a mechanical drawing plan for a custom heat sink to dissipate device heat.
You are a senior hardware engineering 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: thermal resistance calculated from datasheet values without accounting for real mounting interface resistance such as thermal paste and contact pressure, airflow assumptions that don't match the actual enclosure or orientation the device ships in, no margin for ambient temperature variation across the device's real operating environment, and mechanical mounting stress on the heat sink not checked against the PCB or component it's attached to.
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
Build a Hardware Durability Testing System
Build a testing system for evaluating durability and performance of hardware under extreme conditions.
You are a senior hardware engineering 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 conditions that don't match the real-world stress profile such as vibration spectrum or thermal cycling rate the product will actually see, pass/fail thresholds set arbitrarily instead of derived from the actual reliability target, no plan for capturing intermittent failures that only show up under combined stresses like vibration plus heat rather than each stress alone, and test data not correlated back to a failure-mode root cause, so a failure gets logged without anyone learning why.
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
Design a Circuit Troubleshooting Workflow with Failure Isolation and Measurement Discipline
Design a circuit troubleshooting workflow that isolates failures systematically, defines measurement checkpoints, and prevents common misdiagnosis during lab or production debugging.
You are a senior hardware engineering engineer advising on a real implementation rather than teaching a generic tutorial.
Help with the engineering task below.
Context:
- Goal or task: [goal]
- Stack or environment: [stack]
- Current system or surrounding architecture: [current system]
- Constraints such as security, performance, cost, or compatibility: [constraints]
- Scale, criticality, or production expectations: [criticality]
- Specific questions, failure points, or uncertainty: [pain points]
- Success criteria or desired outcome: [success criteria]
Instructions:
1. Explain the approach in the order the team should actually execute it.
2. Tailor the guidance to the stated stack, constraints, and production expectations.
3. Turn the task into concrete technical decisions, not generic setup advice.
4. Explicitly address the failure modes that actually break this in production: replacing a component before confirming it's actually the failure point, an assumption-driven repair without measurement, no systematic signal-tracing order so time gets spent on unlikely causes first, measurement points chosen without considering how the probe or meter itself can load down a sensitive circuit and change the reading, and no documentation of what was tested and ruled out, causing the same dead ends to be re-checked in a later session.
5. Include validation, rollback, review, or monitoring checkpoints where they materially reduce implementation risk.
6. If important context is missing, make explicit assumptions and continue.
Output format:
- Failure-isolation strategy and signal-tracing order
- Measurement points and probe-loading considerations
- Root-cause confirmation before repair
- Documentation to avoid re-testing dead ends
- Main assumptions and risks
Missing information policy:
Ask up to 2 concise questions only if the stack, required outcome, or operational context is unclear. Otherwise proceed with assumptions.
Quality bar:
- Be concrete and operational.
- Prefer implementation judgment over theory.
- Name the specific failure modes above rather than generic best-practices language.
- Make the advice usable by an engineering team shipping real work.
08
Design a Flexible PCB for a Wearable Device
Design a flexible PCB layout for a wearable device with size and functionality constraints.
You are a senior hardware engineering 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: trace routing that crosses the flex bend area perpendicular to the bend axis instead of parallel, causing early fatigue failure, copper weight or trace width chosen the same as a rigid board without accounting for flex-cycling stress, no defined minimum bend radius enforced in the layout, and connector or stiffener placement that doesn't account for repeated mechanical stress at the transition point.
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.
09
Create a Bill of Materials for an Embedded System
Create a bill of materials for a custom-designed embedded system.
You are a senior hardware engineering practitioner creating a reusable engineering asset for a real team workflow.
Build the asset using the context below.
Context:
- Goal of the asset: [goal]
- System or project context: [context]
- Audience using it: [audience]
- Constraints, standards, or compliance needs: [constraints]
- Quality risks, failure modes, or review focus: [risk focus]
- Stage of use such as design, implementation, release, or incident response: [stage]
Instructions:
1. Create an asset that is immediately usable in a real workflow.
2. Keep the structure concise and scannable, but include the checks that materially affect quality, safety, or operability.
3. Prioritize the checks that catch real failures over generic completeness: components listed without manufacturer part numbers or approved alternates, blocking procurement the moment the primary source is out of stock, no lifecycle or obsolescence status tracked so a design gets built around a part that's about to be discontinued, tolerance and rating fields omitted so substitutions look interchangeable when they aren't, and no revision or version tracking so a BOM change isn't traceable to the design change that caused it.
4. If the asset is a checklist, organize it by stage, severity, or decision point rather than a flat list.
5. Add short usage guidance when it improves consistency or judgment.
6. Make sure the asset helps a team catch real failure modes before they ship or escalate.
Output format:
- Bill of materials structure (part numbers, alternates, ratings)
- Lifecycle and obsolescence tracking
- Revision history and change traceability
- Main failure modes or review notes
Missing information policy:
Ask up to 2 concise questions only if the goal, audience, or context is unclear. Otherwise proceed with assumptions.
Quality bar:
- Keep it practical.
- Make the structure reusable.
- Name the specific failure modes above rather than generic checklist bloat.
- Emphasize the checks that prevent real mistakes.
10
Design a Sensor Selection Framework for an IoT Device with Accuracy and Integration Tradeoffs
Design a sensor selection framework for an IoT device that weighs accuracy, calibration burden, environmental fit, interface constraints, and total integration cost.
You’ll neediot use caseenvironmentmeasurement needspower budgetintegration constraintsconstraints
Prompt
You are a senior hardware engineering engineer advising on a real implementation rather than teaching a generic tutorial.
Help with the engineering task below.
Context:
- Goal or task: [goal]
- Stack or environment: [stack]
- Current system or surrounding architecture: [current system]
- Constraints such as security, performance, cost, or compatibility: [constraints]
- Scale, criticality, or production expectations: [criticality]
- Specific questions, failure points, or uncertainty: [pain points]
- Success criteria or desired outcome: [success criteria]
Instructions:
1. Explain the approach in the order the team should actually execute it.
2. Tailor the guidance to the stated stack, constraints, and production expectations.
3. Turn the task into concrete technical decisions, not generic setup advice.
4. Explicitly address the failure modes that actually break this in production: choosing a sensor based on datasheet accuracy specs alone without accounting for the actual environmental conditions like temperature drift, humidity, or vibration it will operate under, underestimating the calibration or signal-conditioning burden a cheaper sensor adds to the rest of the system, an interface choice such as analog vs digital or I2C vs SPI that doesn't match the microcontroller's available pins or timing budget, and no plan for sensor drift or failure over the device's expected lifetime.
5. Include validation, rollback, review, or monitoring checkpoints where they materially reduce implementation risk.
6. If important context is missing, make explicit assumptions and continue.
Output format:
- Selection criteria weighted by real operating conditions
- Interface and integration fit with the microcontroller
- Calibration and signal-conditioning burden
- Long-term drift and failure planning
- Main assumptions and risks
Missing information policy:
Ask up to 2 concise questions only if the stack, required outcome, or operational context is unclear. Otherwise proceed with assumptions.
Quality bar:
- Be concrete and operational.
- Prefer implementation judgment over theory.
- Name the specific failure modes above rather than generic best-practices language.
- Make the advice usable by an engineering team shipping real work.
11
Design a Sensor Interface Circuit for a Microcontroller
Design an interface circuit connecting a microcontroller to an external sensor module.
You are a senior hardware engineering 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: no level-shifting or protection circuitry when the sensor and microcontroller operate at different voltage levels, signal noise or ground loop issues from a long or unshielded sensor cable run not accounted for, pull-up or pull-down resistor values chosen without checking the microcontroller's actual input characteristics, and no protection against a sensor being connected backwards or hot-plugged.
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
Automate Voltage, Current, and Power Calculations
Write a script to automate voltage, current, and power rating calculations for a circuit.
You are a senior hardware engineer.
Produce code or a code scaffold for a voltage, current, and power rating calculation 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: using room-temperature component ratings without derating for actual operating temperature, ignoring transient or inrush current spikes that exceed steady-state ratings and can damage components even when average power looks fine, tolerance stack-up across multiple components not accounted for so worst-case combinations are missed, and safety margin left at zero instead of the standard derating factor engineers actually design to.
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 worst-case tolerance stack-up)
- 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
Create a Thermal Performance Test Plan for a Power Supply
Create a test plan for evaluating the thermal performance of a power supply circuit.
You are a senior hardware engineering 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: thermal testing done only at nominal input voltage and load instead of across the full specified range, no test for thermal behavior during a fault condition like a shorted output, ambient temperature during testing not controlled or logged which makes results non-reproducible, and thermal shutdown or protection circuitry never actually triggered and verified during the test.
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
Develop an Automated Diagnostics System for Prototypes
Develop an automated system for running diagnostics on hardware prototypes during testing.
You are a senior hardware engineering 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: diagnostics that only check for hard failures and miss marginal or intermittent faults that show up under specific conditions, no logging of diagnostic results in a form that lets patterns be compared across multiple prototype units, test sequencing that doesn't isolate which subsystem actually failed when a downstream test fails, and no plan for diagnosing a unit that fails to power on at all, outside the scope of diagnostics that assume power already works.
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.
15
Design a Robust Grounding System
Design a robust grounding system for an industrial control system to reduce interference.
You are a senior hardware engineering 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: mixing signal, power, and chassis ground without a clear single-point or star-ground strategy, leading to ground loops and interference, ground plane impedance not considered at the frequencies actually present in the system, grounding retrofitted after the layout is already done instead of planned alongside it, and no verification step such as a ground-loop or continuity test after installation to confirm the design actually behaves as intended.
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.
16
Create a Hardware Design-to-Test Flowchart
Create a flowchart for designing, prototyping, and testing a new electronic product.
You are a senior hardware engineering practitioner creating a reusable engineering asset for a real team workflow.
Build the asset using the context below.
Context:
- Goal of the asset: [goal]
- System or project context: [context]
- Audience using it: [audience]
- Constraints, standards, or compliance needs: [constraints]
- Quality risks, failure modes, or review focus: [risk focus]
- Stage of use such as design, implementation, release, or incident response: [stage]
Instructions:
1. Create an asset that is immediately usable in a real workflow.
2. Keep the structure concise and scannable, but include the checks that materially affect quality, safety, or operability.
3. Prioritize the checks that catch real failures over generic completeness: no defined exit criteria between stages, so a design moves to the next phase before problems from the prior stage are actually resolved, test coverage that only checks the happy path and skips stress, thermal, or failure-mode testing until it's too late to fix cheaply, no feedback loop from testing back into the design stage baked into the flowchart, and manufacturing or production concerns left out until the very end instead of considered from prototype stage.
4. If the asset is a checklist, organize it by stage, severity, or decision point rather than a flat list.
5. Add short usage guidance when it improves consistency or judgment.
6. Make sure the asset helps a team catch real failure modes before they ship or escalate.
Output format:
- Staged flowchart with defined exit criteria
- Test coverage by stage (functional, stress, thermal, failure mode)
- Feedback loop from test back to design
- Main failure modes or review notes
Missing information policy:
Ask up to 2 concise questions only if the goal, audience, or context is unclear. Otherwise proceed with assumptions.
Quality bar:
- Keep it practical.
- Make the structure reusable.
- Name the specific failure modes above rather than generic checklist bloat.
- Emphasize the checks that prevent real mistakes.
17
Build an EMI Simulation Model for a Circuit
Build a simulation model to predict electromagnetic interference behavior in a circuit.
You are a senior hardware engineering 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 radiated emissions but ignoring conducted emissions through power and signal cables, which often dominate real-world failures, component and trace parasitics simplified away in a way that hides the actual coupling paths, no correlation plan to validate the simulation against real EMI chamber measurements, and simulation run only at the fundamental switching frequency while the harmonics that actually fail compliance testing are ignored.
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.
18
Evaluate Long-Term Microchip Reliability
Develop a method for evaluating long-term microchip reliability in harsh environments.
You are a senior hardware engineering 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: accelerated life testing conditions chosen without a valid acceleration model, making the extrapolated lifetime meaningless, failure modes from real harsh-environment mechanisms like thermal cycling fatigue or humidity ignored in favor of easier-to-run tests, sample size too small to say anything statistically meaningful about failure rate, and no distinction between infant-mortality failures and wear-out failures when interpreting results.
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.
19
Design an ESD-Safe Handling and Storage Procedure for Sensitive Components
Design an ESD-safe handling and storage procedure for sensitive components that fits lab, production, or manufacturing workflows with clear failure-prevention controls.
You’ll needcomponent typesstorage environmentworkflow settinghandling volumecompliance or quality requirementsconstraints
Prompt
You are a senior hardware engineering engineer advising on a real implementation rather than teaching a generic tutorial.
Help with the engineering task below.
Context:
- Goal or task: [goal]
- Stack or environment: [stack]
- Current system or surrounding architecture: [current system]
- Constraints such as security, performance, cost, or compatibility: [constraints]
- Scale, criticality, or production expectations: [criticality]
- Specific questions, failure points, or uncertainty: [pain points]
- Success criteria or desired outcome: [success criteria]
Instructions:
1. Explain the approach in the order the team should actually execute it.
2. Tailor the guidance to the stated stack, constraints, and production expectations.
3. Turn the task into concrete technical decisions, not generic setup advice.
4. Explicitly address the failure modes that actually break this in production: grounding straps or ESD mats that are present but never verified for continuity, giving a false sense of protection, humidity and static buildup risk not accounted for in storage rather than just handling, components moved between ESD-safe and non-safe areas with no clear boundary or checkpoint, and no incident process for when an ESD event is suspected, so damaged parts silently make it into assembly.
5. Include validation, rollback, review, or monitoring checkpoints where they materially reduce implementation risk.
6. If important context is missing, make explicit assumptions and continue.
Output format:
- Handling and grounding verification procedure
- Storage environment controls
- ESD-safe/non-safe area boundaries and checkpoints
- Suspected-ESD-event response process
- Main assumptions and risks
Missing information policy:
Ask up to 2 concise questions only if the stack, required outcome, or operational context is unclear. Otherwise proceed with assumptions.
Quality bar:
- Be concrete and operational.
- Prefer implementation judgment over theory.
- Name the specific failure modes above rather than generic best-practices language.
- Make the advice usable by an engineering team shipping real work.
20
Design a Bluetooth PCB with Power-Saving Features
Design a custom PCB for a Bluetooth-enabled communication device with power-saving considerations.
You are a senior hardware engineering 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: antenna placement and ground clearance not verified against the module manufacturer's reference design, degrading range unpredictably, power-saving modes implemented in firmware but undermined by PCB-level always-on regulators or LEDs draining current regardless, RF trace impedance not matched, causing reflections and reduced range, and no shielding or isolation between the RF section and noisy digital or power circuitry on the same board.
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.
21
Create a Signal Integrity Verification Procedure
Create a procedure for testing and verifying signal integrity in high-speed digital circuits.
You are a senior hardware engineering 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: verification done only at DC or low frequency when the actual signals of concern are high-speed and dominated by reflections and crosstalk, no controlled-impedance verification against the actual PCB stack-up used in production, test points that themselves introduce enough parasitic capacitance to change the signal being measured, and eye-diagram or timing margin evaluated only under best-case conditions instead of worst-case process, voltage, and temperature corners.
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.
22
Create Hardware Regulatory Compliance Guidelines
Develop guidelines for ensuring compliance with standards such as RoHS and CE during hardware design.
You are a senior hardware engineering practitioner creating a reusable engineering asset for a real team workflow.
Build the asset using the context below.
Context:
- Goal of the asset: [goal]
- System or project context: [context]
- Audience using it: [audience]
- Constraints, standards, or compliance needs: [constraints]
- Quality risks, failure modes, or review focus: [risk focus]
- Stage of use such as design, implementation, release, or incident response: [stage]
Instructions:
1. Create an asset that is immediately usable in a real workflow.
2. Keep the structure concise and scannable, but include the checks that materially affect quality, safety, or operability.
3. Prioritize the checks that catch real failures over generic completeness: compliance treated as a final pre-launch checklist instead of a design constraint considered from the start, region-specific requirements like RoHS in the EU conflated as if one standard covers all target markets, documentation or testing evidence not retained in a form that survives an audit, and component substitutions made late in the process without re-verifying they still meet the compliance requirements the original part had.
4. If the asset is a checklist, organize it by stage, severity, or decision point rather than a flat list.
5. Add short usage guidance when it improves consistency or judgment.
6. Make sure the asset helps a team catch real failure modes before they ship or escalate.
Output format:
- Compliance requirements by target market
- Design-stage checkpoints (not just pre-launch)
- Documentation and audit-evidence retention
- Main failure modes or review notes
Missing information policy:
Ask up to 2 concise questions only if the goal, audience, or context is unclear. Otherwise proceed with assumptions.
Quality bar:
- Keep it practical.
- Make the structure reusable.
- Name the specific failure modes above rather than generic checklist bloat.
- Emphasize the checks that prevent real mistakes.
23
Design a Custom Power Management IC
Design a custom PMIC for a battery-powered device with clear power goals and constraints.
You are a senior hardware engineering 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: efficiency curves evaluated only at typical load, missing the light-load and no-load quiescent behavior that dominates battery life in real usage, sequencing and timing requirements between power rails not verified against what the downstream ICs actually require at power-up, protection features like overcurrent and thermal shutdown designed in but never tested at the actual trip point, and no margin left for battery voltage sag under load, which can cause improper sequencing right when the device needs power most.
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.
24
Log Real-Time Embedded Performance Data in the Field
Write a script to monitor and log real-time performance data from embedded systems during field testing.
You’ll needdevice typemetrics to logfield conditionsconstraints
Prompt
You are a senior hardware engineer.
Produce code or a code scaffold for a real-time embedded performance logging script for field testing.
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: logging at a fixed sample rate that misses transient events happening faster than the sample interval, no buffering or local-storage plan so a lost connection during field testing means unrecoverable data loss, timestamp or clock drift between the logging device and reference time source making cross-device correlation unreliable, and sensor or measurement outliers logged as if valid instead of flagged.
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 outlier flagging)
- 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.