Prompting Guide: Working with Flux from Idea to Schematic

If you haven’t seen what’s changed, read the launch blog for the full story.

This guide shows how to collaborate with Flux at the schematic stage. You’ll learn how to describe your intent clearly, guide the AI through design decisions, and review results so each iteration gets smarter.

Flux isn’t magic — it’s more like a fast, thoughtful AI hardware engineer. With the right collaboration, it can turn your idea into a manufacturable schematic while you stay in control of the design. Flux also can't generate a full board in one go. Instead, make sure to split the process in steps and use AI to get you to the next stage. Let’s start by learning how to work with Flux to:

• Define your project requirements with Flux
• Review Flux’s plan and provide more details
• Go block by block to build out the schematic diagram

This workflow allows you to move fast while keeping control. The sections below walkthrough how to write great prompts.

‍

1. Define your project requirements with Flux

Start by describing what you're building, why it matters, and who it's for. This gives Flux enough context to generate a reasonable plan that typically includes system-level architecture. After the initial prompt, with planning mode activated, Flux will generate a plan you can approve or modify. Then, click start to watch it work.

The following prompt template works well for kicking projects off because it sets intent (why), scope (what), and constraints (how).

Use this formula:

‍Make me a {what it is} with {connectivity}, powered by {power} for {application}.

Followed by detailed info:
{detailed what it is} with {detailed connectivity}, powered by {detailed power}.

Example:

‍Make me a {portable stereo Class-D speaker} with {Wi-Fi and Bluetooth}, powered by {a multi-cell Li-ion/LiPo battery} for {consumer use}.

It should be a compact stereo system with dual Class-D amps (2×10–25 W), basic DSP or MCU tone controls, dual-radio Wi-Fi + BLE (2.4 GHz 802.11 b/g/n plus BLE 5.x), and a Li-ion/LiPo BMS with balancing and pack monitoring.

Tips

• Prompts like “build a BLDC driver with everything” are too vague—Flux may chase irrelevant solutions.
• You don’t need to name parts. Describe intent and relationships—Flux will pick reasonable defaults.

‍

2. Review Flux’s plan and provide more details

The plan that Flux generates typically benefits from more specificity on the systems and subsystems before you approve it. So, be sure to review and make sure everything makes sense before you have Flux start executing the plan. At this stage you can follow Flux’s initial system-level architecture suggestion and let it help you reason through the role of each block, interfaces, and signal flow.

Use this formula for providing more details:

- Power: [voltage rails, current needs]
- Communication: [interfaces between blocks]
- Environment: [thermal, ingress, EMI, etc.]
- Etc.

Design goal: [priorities or trade-offs]

Example:

- Audio block: drives two 10–25 W Class-D amplifiers using a stereo signal path. Includes simple EQ via a low-cost DSP or microcontroller, and volume control from a rotary encoder. Accepts I²S or analog input.
‍
- Connectivity block: dual-radio module (Wi-Fi 802.11 b/g/n and BLE 5.x) for audio streaming and pairing. Includes antenna interface, UART/SPI communication with MCU, and audio over I²S.
‍
- Power block: multi-cell Li-ion/LiPo battery with BMS. Provides 3.3 V rail for logic, 5 V rail for radio, and higher-voltage boost for amplifier rails. Supports charging via USB-C with protection. Battery input with boost converters and LDOs as needed
‍
- Communication: UART/SPI for control, I²S for audio signal path
‍
- Environment: Consumer-grade enclosure, ambient temp 0–40 °C, continuous playback for 8+ hours
‍
- Design goal: Balanced power and audio performance

Why this works: Each block has a role, the interfaces are clear, and design priorities are actionable. This helps Flux recommend components and validate architecture.

Tip: Stay at the system level. Don’t worry about exact pin counts or part numbers yet.

‍

3. Go block by block to generate your schematic diagram

With the architecture in place, pick one block and go deep. This is where you can ask Flux to draft a schematic or layout based on specific inputs and constraints.

Flux typically works best when you break up schematic generation step by step picking one block at a time and going deep. This is where you can ask Flux to draft a schematic or layout based on specific inputs and constraints.

Flux can research components, place them into the schematic, and wire up the nets for you. Although sometimes the resulting layout might look different than you’d expect, you can always jump in and organize things however you like.

Use this formula:

We’re designing the [block name] for this project.

Inputs:
- [Power inputs and characteristics]
- [Signal inputs, interfaces, or control lines]

Requirements:
- [Functional goals—e.g., voltage regulation, signal processing]
- [Performance targets—e.g., power budget, timing, noise]
- [Constraints—e.g., size, cost, runtime, safety]

Protection:
- [What to protect against—e.g., ESD, reverse polarity, EMI]
‍
Design goal:
- [Overall priority—e.g., efficiency, safety, manufacturability]

Example:

Let's design the power management block.

Inputs:
- 3.7V Li-ion battery (2000 mAh)
- USB-C input for charging

Requirements:
- Charge controller with input current limit and battery protection  
- Boost to 3.3 V for digital logic and 5 V for gas sensors  
- 48-hour runtime target at ~50 mA average current  
- Battery voltage and charge status monitoring via I²C

Protection:
- ESD on USB-C  
- Reverse polarity and over-discharge protection

Design goal: Efficient, compact, and safe for consumer use

Tip: Link datasheets or PDFs for reference—Flux can match its design to those specs.

‍

4. Understanding Flux’s two modes for planning or one-off edits

Flux AI operates in two complementary modes—one for exploration, one for precision. Use the planning mode when you’re exploring ideas or starting from scratch. It’s great at figuring out workflows and proposing architectures.

Use the single task mode by disabling planning when you need control—editing one block, fixing small issues, or checking results. To disable planning mode, hover over the AI icon at the bottom of the chat menu and click on “disable planning”.

‍

5. Common pitfalls

After helping hundreds of users across the Flux community, we’ve noticed some common stumbling blocks when working with the AI. Most of these are easy to fix once you know what to look out for.

Here are a few patterns to avoid:

1. Over-specifying too early
   Don’t lock in unnecessary details before validating your concept. Let the AI help you explore options.
2. Being too vague
   Prompts without power, environment, or application context are hard to act on. The more relevant detail you include, the better the AI performs.
3. Skipping constraints
   Without voltages, sizes, or thermal needs, Flux will make guesses that may not match your requirements.
4. Ignoring follow-up questions
   Treat AI clarifications as helpful nudges—they often help reduce back-and-forth.
5. Letting errors pile up
   If something seems off, don’t wait. Refine your prompt and re-run the block instead of continuing with bad assumptions.

The earlier you correct course, the faster you get to a working design.

‍

6. Known rough edges

Flux’s AI is improving fast, but there are still a few areas where you may need to step in. We want to be upfront about what’s working well—and what still needs a human touch.

Here’s what to expect:

Known limitations:

• Wiring gaps: Sometimes the AI misses a connection or leaves a net unconnected.
• Placeholder or generic parts: Not every component will be production-ready out of the gate. Replace with specific parts once the concept is locked in.
• Partial BOMs: Passive components, filtering, or protection may be missing. Ask the AI to review and fill in what’s missing based on your specs or linked datasheets.

What’s next?

Flux is rapidly growing its AI capabilities to support:

• Change PCB sizing and layer stackups
• Generate net classes and design rules
• Optimize part placement
• Route traces with design constraints in mind

Ready to try it?

Every great board starts with a clear idea. Whether you’re designing your first schematic or refining a production layout, better prompting leads to better results.

Use this guide to help Flux work like the AI hardware engineer you’ve always wanted—fast, reliable, and just a prompt away.

👉 Open Flux and see how far your next idea can go.