Flux's AI agent is now up to 10x faster and self-corrects in real time, delivering cleaner schematics with less waiting and fewer wasted credits.
Flux helps you design with live pricing and stock data, using AI to find in-stock parts and fast replacements before your BOM breaks.
Flux takes a different approach. Instead of treating pricing and availability as a post-design concern, Flux keeps live supply data connected to your project as you work. Your project becomes a living document that stays aligned with the supply chain, surfacing constraints early—when decisions are still flexible and changes are cheap.
When you browse and select parts in the part library, Flux shows pricing and availability so you can spot sourcing constraints early. The Part Library panel is collapsed by default—expand it to see full pricing and availability details. You can also filter by stock status using the cart icon to show only available components.
Ask Flux AI to find parts that are in stock—it searches real-time supply chain data and understands your full project context. Instead of manually checking distributor websites, you get parts from the library that match your requirements and constraints.
Example prompt:
"I need a 16-bit ADC with at least 1 MSPS sampling rate for a battery monitoring application. Find what’s available within 2 weeks?"
Ask Flux AI to find a replacement that's in stock. It understands your full project context, including what the part connects to, how you're using it, and your design requirements and constraints, and suggests parts with similar packages and specifications.
It prioritizes availability over minor price differences and recommends parts already in the library, so you don't have to build them from scratch. Once you select a replacement, Flux AI can automatically drop it onto the canvas and wire it up for you.
Example prompt:
"Can you find me a cheaper replacement for U2?"
To check availability for a part, click on it in your design to open the inspector panel on the right. Scroll to the bottom, and you'll see real-time stock levels across multiple distributors—Arrow, Mouser, DigiKey, LCSC, Verical, and TME. This gives you a clear picture of whether a part is widely available or at risk of supply chain issues. If the part isn't in Flux's library, the system can search the broader internet to find availability data.
Note: You'll need a manufacturer part number (MPN) defined in the MPN property for generic parts.
Supply chain constraints don't go away once you've finalized your design—they just become more expensive to fix. The earlier you catch them, the more options you have.
Start treating sourcing as a design constraint, not a procurement problem. Check availability when you select parts. Let Flux AI flag risky components before you commit to a layout. And when something goes out of stock, find alternatives while you still have room to adjust.
The tools are already in your workflow. Use them before the BOM forces your hand.
{{try-it-in-flux}}
AI Auto Layout’s Winter Update delivers cleaner, more human-like routing with faster, more reliable results. It handles most of the routing workload so you can focus on the critical parts of your PCB design.
Thousands of you put it through its paces. You tried it on real boards, found its edges, and told us exactly what would make it more useful in your workflow. Your feedback shaped every improvement in this release.
This update builds on the same vision as the first release. Layout should feel intuitive from setup to review, and AI should handle the repetitive work so you can stay focused on design.
This version of the model is not designed to fully autoroute every class of board without your input. You should still expect to step in for high speed interfaces, tight length matching, unusually thick power nets that land on small pads, and designs with strict layer reservations. The sweet spot today is a workflow where you define the important constraints and critical paths, then let AI Auto Layout finish the remaining 80 percent.
The more context you give AI Auto Layout, the better the results. When rules are realistic, sensitive areas are protected, and critical signals are handled up front, the router can focus on what it does best: finishing the busy work in a way that looks like a human EE’s layout.
If you want to see what a well-prepared setup looks like, check out this ESP32 Espresso Smart Scale project. You can even run AI Auto-Layout to see it perform it’s magic.
Here is a quick checklist to prepare your board before you run Auto Layout.
Learn more about how to setup your project by watching this video tutorial or reading the documentation on AI Auto-Layout.
Traditional autorouters treat routing as a geometry puzzle. They chase shortest paths and resolve constraints, but ignore the realities that matter to engineers: manufacturability, signal behavior, and the ability to understand the layout at a glance. The result is familiar. Tangled traces. Excessive vias.
AI Auto Layout approaches the problem differently. It learns patterns that resemble human decision-making and adapts its choices as it routes, which leads to results that feel deliberate, balanced, and easier to work with.
This update sharpens that behavior. The routing is cleaner, straighter, and more aligned with your placement intent. You will see fewer unnecessary layer transitions, more predictable via placement, and stronger power paths. Layouts are easier to review, reason about, and move toward manufacturable results. In many cases, the output looks like a thoughtful first pass from an experienced engineer.
Clean Power Distribution: Auto-Layout routed the 5V0 and 3V3 rails with solid continuity, avoiding broken return paths and keeping them isolated from noisy elements like the antenna and full-speed SD card. The result is stable power delivery with fewer opportunities for interference.
Reliable Signals Across High-Power Copper: Auto-Layout navigated routing around high-power copper while preserving the integrity of critical feedback signals. The results are cleaner paths, fewer compromises, and a design that behaves exactly as intended.
Less Layer Transitions and Vias: By intelligently routing traces, it creates cleaner signal paths, improves electrical performance, and helps simplify manufacturing. The result is a more efficient, robust board design with fewer potential points of failure and often lower production costs.
High-Speed Signal Pathfinding: Auto-Layout roughed in clean first-pass routes for medium-complexity boards, including a 3-lane MIPI-CSI interface, the ESP32’s QSPI bus, and its critical clock lines. It maintained proper layer separation, avoiding routing traces directly beneath each other on adjacent layers to help preserve signal quality.
AI Auto Layout is faster in this release. On well prepared boards, the new model reaches strong solutions sooner and stops when further search is unlikely to improve quality. You avoid long, wandering runs and get to a clean layout much more predictably.
On simple two layer boards without sensitive nets, you should expect a complete route in minutes. Boards with dense placement, large trace widths, or strict layer reservations will take longer, but the model now recognizes when it has converged so it avoids wasting credits on unproductive search.
AI credit usage varies based on design complexity, routing constraints, and the length of the run. Here are reference points to help you plan.
If your board includes complex exceptions, tight fanouts, thick power nets that must enter small pads, or manually reserved layers, it may require additional credits. You can always see your live credit usage while the job runs.
This update makes both time and credits more predictable. When the router is progressing toward a strong solution, it continues. When it has reached a point of diminishing returns, it stops. That balance keeps your workflow moving and helps you budget runs more effectively across both two and four layer designs.
This update moves AI Auto Layout closer to the experience many of you have been asking for: cleaner routing, better electrical behavior, faster convergence, and layouts that move you toward a manufacturable board with less effort. It now handles both two and four layer designs more reliably, especially when you provide clear rules and route your most sensitive nets before handing off the rest.
We would love to hear how it performs on your next project. Try it on a real board, share your results, and tell us what you want to see next. Your feedback continues to shape every release.
Try it out today and let us know what you think in Slack.
{{try-ai-auto-layout-today}}
{{underline}}
Traditional autorouters focus on connectivity and shortest paths, which often produces layouts that are tangled, brittle, or difficult to review. AI Auto Layout reasons over placement, net classes, and electrical intent. It places vias more intentionally, follows natural routing channels, and stops when it reaches a strong solution. The result looks closer to a thoughtful first pass from an experienced engineer.
AI Auto Layout performs well on many two and four layer designs, especially when you provide clear rulesets and manually route the most sensitive nets first. It can fully route simple and moderately complex boards. Larger or more constrained designs also work well when critical nets, tight timing paths, or strict layer reservations are guided by hand before running the AI.
On well-prepared two layer boards without sensitive nets, most runs complete in minutes. Four layer and up designs vary more based on placement density, routing constraints, and net priorities. The model is tuned to recognize diminishing returns, so it avoids wasting credits.
Credit usage depends on component count, constraints, and overall geometry. Typical ranges:
You can see your live credit usage while the job runs.
You will get the best results if you:
This mirrors the workflow most teams use when blending manual routing with AI assistance.
Yes. You can define rulesets by net class, set trace widths and clearances, choose via sizes, add zones and keepouts, and guide placement with manual fanouts. Clear, realistic constraints significantly improve results.
Throughout this process, your data remains yours. We employ robust encryption and modern data centers to keep your information secure, just like the trusted cloud services you rely on daily. If you want to learn more, please take a look at our Privacy Statement.
Practical guide to writing prompts that get quality results from Flux. We’ll talk about the anatomy of a good prompt and how you can use different LLMs to come up with a great prompt.
Here’s a practical guide to writing prompts that get quality results from Flux. We’ll talk about the anatomy of a good prompt and how you can use different LLMs to come up with a great prompt.
Models behave like fast, literal collaborators. They do best when you hand them the same things you’d give a new teammate: context, constraints, and a definition of “done.” OpenAI, Anthropic, and Microsoft all emphasize the same fundamentals; be specific, provide context and examples, and iterate because models respond measurably better to concrete instructions than vague goals.
For hardware, that specificity translates into;
PCB design is now starting the same way, with a sentence that sets direction. The right workflow turns that sentence into a plan, and that plan into a real board.
A strong prompt has structure. You don’t need to overthink it — just fill in the blanks like you would for a teammate’s design request.
Once you’ve written that out, you’ll notice something: it’s the same info you’d include in a solid design doc. You’re just telling it to the AI in natural language.
Bad
“Design a PCB to power my sensor node.”
Better
Create a compact, two-layer PCB for a battery-powered environmental sensor that can measure temperature and humidity outdoors year-round.
Functions: Step down Li-ion voltage (3.0–4.2 V) to a stable 3.3 V @ 500 mA to power an MCU and BLE module, while maintaining low noise for accurate sensor readings.
Power model: Single-cell Li-ion input with optional USB-C charging and reverse-current protection; system should support sleep modes with minimal quiescent draw.
Key constraints: Total board area ≤ 2 cm²; must use widely available components from LCSC or Mouser; prioritize efficiency (≥ 85%) and long battery life over BOM cost; all parts hand-solderable and suitable for low-volume prototyping.
Interfaces & I/O: I²C bus for sensors, UART header for debugging, JST-PH connector for the battery, and test points for power rails and signal lines.
Replace the bracketed parts, and keep it as one block.
Below is a single-block prompt example for an enterprise-style project. Use the structure and adapt the content.
OzCorp’s building a robotic arm for its Kitchen Independence line—assistive gear to help folks with limited mobility cook safely. It’ll live near stovetops, inside semi-sealed enclosures, and handle risky, high-precision tasks. We need a v1 board for early testing—tight stack, safe motion, easy to iterate.
Board should be quiet, cleanable, fault-tolerant, and built with safety-first motor control. Design for real-world abuse, not just the bench.
Requirements:
* Thermal: Run clean near 70°C, layout ready for passive shielding.
* Ingress: Tolerate steam/oil, avoid exposed headers, semi-wipeable.
* EMI: Survive near induction tops; solid filtering and layout.
* Motors: Drive 4–6 steppers or BLDCs w/ encoders, quiet + smooth.
* IO: Temp + proximity sensors; USB-C or UART; room for add-ons.
Primary input will be a 24 V DC external supply—off-the-shelf medical-grade adapter. Budget ~5 A peak, ~2 A continuous for everything. Motors are 24 V BLDCs with integrated drivers, so we don’t need separate gate drive rails.
Rails we’ll need:
* 24 V passthrough for motors
* 5 V rail for sensors, logic level translators, and E-stop handling
* 3.3 V clean rail for MCU and digital IO
* 2.8 V, 1.8 V and 2.3 V analog-only rails for the camera
* No additional rails, however, keep layout flexibility in mind in case we add additional sensing later.
No galvanic isolation needed between motor and logic domains in this rev—common ground is fine as long as noise coupling is controlled. Just prioritize good filtering and separation in the layout.
We’re targeting a higher-end embedded MCU—something with enough headroom for real-time motor control, sensor fusion, and field updates without jumping to a full MPU. Needs to support external memory and camera input via MIPI CSI (basic CV down the line), and ideally has built-in Ethernet MAC with PoE support for hardwired installs.
We’re also dropping in a discrete Zigbee radio—most of the Kitchen Independence line will communicate over a shared Zigbee mesh for interoperability and OTA updates, so we’ll need clean SPI or UART for that interface, plus a decent RF layout budget. USB device is a must, USB host is a nice-to-have. No Linux this rev—we’re keeping it lean and RTOS-friendly.
This approach resembles a planning meeting rather than a netlist, allowing for a more comprehensive and strategic overview. By defining environment and safety considerations early, it significantly influences and shapes the overall architecture. Additionally, it outlines the rails and interfaces without prematurely committing to specific chips, providing greater flexibility. This method also leaves room for the agent to propose blocks and components that align with and satisfy the project's goals.
Once your requirements are clear, bring them to life. Paste your brief into a new project in Flux, and watch as your AI assistant turns that structured intent into a concrete starting point.
Flux’s AI agent doesn’t replace that balance; it amplifies it. When you give it clarity, it gives you momentum. When you ask better questions, it becomes a sharper collaborator.
Plan like a product team, define clearly, and let the AI handle the first draft of your design.
The future of hardware starts here, open Flux and start your next project today.
Are you creating the right hardware solution for the problem that truly matters? Learn how to validate ideas, prototype fast, and use modern tools to turn concepts into successful products.
But the world has changed. The cost to experiment has collapsed. AI is leaving the cloud to run on devices the size of a thumbnail. Sensors that once cost hundreds now sell for pennies. For the first time, small teams can move with the creative velocity that software startups have enjoyed for decades. The gap between idea and reality has never been smaller.
And yet, most hardware startups still fail. Only about twenty percent of hardware projects on Kickstarter reach their funding goal, and many of those never ship. Among venture-backed companies, few make it past their first product.
They fail because they mistake building for learning. They fall in love with the object instead of the problem it solves. In software, you can fix mistakes overnight. In hardware, your mistakes ship with the product - literally.
So how do you tell a promising idea from a doomed one? You can’t predict success, but you can evaluate your idea through a few simple, revealing lenses.
Most failed startups didn’t build the wrong product. They built the right product for a problem nobody cared about.
The first filter is pain. Would your users notice if your product disappeared tomorrow? Would they try to hack together a replacement because it mattered that much? A “nice to have” idea might work in software, but in hardware, where every prototype costs time and money, it’s a fatal flaw.
Look for problems that are deeply felt, not just acknowledged. If you can’t name the specific moment your user feels that pain, you haven't dug deep enough.
A brilliant idea is useless if you can’t get it into people’s hands.
Ask yourself: how quickly can I put a prototype in front of ten real users? If the answer involves resellers, trade shows, or corporate pilots, your learning loop is already too slow.
The best founders start where their users already are. They spend time in the workshop, the clinic, the lab, or the kitchen. They observe people in their natural context and test ideas directly. That’s where clarity comes from. If you can’t easily access your early adopters, you’ll waste months designing in the dark.
A beautiful prototype can still make a terrible business.
Before you commit, stress-test the economics. Can you build it at a margin that leaves room to scale? Is there a recurring element, consumables, data, upgrades, or community, that compounds value over time?
If your business model relies entirely on one-time sales, you will be running uphill forever. Hardware margins are thin, so your value has to run deep. The goal isn’t just to make an object; it’s to build a system that sustains itself and the people behind it.
The best ideas rarely come from brainstorming. They come from lived experience.
Tony Fadell didn’t build Nest because he wanted to make thermostats cool. He built it because he was frustrated by how wasteful and outdated they were. Frank Wang started DJI after crashing his own helicopter and realizing flight should be simple. Nirav Patel created Framework because he hated throwing away laptops that should have been repairable.
The common thread is proximity. These founders were close to the problem. They understood it deeply enough to recognize what “better” looked like.
If you’re forcing an idea, it’s probably not the right one. The ideas worth building are the ones that won’t leave you alone.
Once you have clarity on these questions, it’s time to learn through prototypes. Each build should have a clear learning goal. You are not building to finish; you are building to learn.
The point is intentionality. Know what you are trying to learn from each version before you start building. Every successful hardware company runs on validated learning.
Every prototype closes a gap between what you think is true and what actually works in the real world.
For example, you could start prototyping a product idea right now. Try it for yourself:
Create a solar-powered IoT environmental sensor node. The goal is to design a compact and energy-efficient PCB for outdoor environmental monitoring applications.
The device should be powered by a small solar panel with a built-in Li-ion battery charging and protection circuit. It will include sensors for temperature, humidity, air quality (CO₂ or VOC), and light intensity. The design should use a low-power microcontroller such as an ESP32, STM32L0, or nRF52, and communicate via LoRaWAN or Wi-Fi. The circuit should incorporate proper power management, voltage regulation, and an ultra-low sleep current design, with a USB-C port for debugging and charging.
Generate a complete schematic with labeled subsystems, including power, sensors, microcontroller, and communication sections. Produce a compact PCB layout optimized for solar and battery integration, along with a suggested component list that includes part numbers. Provide design notes for a waterproof enclosure and antenna placement, and include a manufacturability and testing checklist to ensure production readiness.
{{hardware-founder-prompt-idea}}
Speed used to be hardware’s enemy. Now, it's the ultimate advantage.
Teams that can run five iterations in a few months will outlearn those that spend a year polishing a single version. The best companies make iteration a habit, not a milestone. Whoop tested its early wearables on professional athletes who cared more about results than polish. Oura shipped multiple versions before getting the form factor right.
Iteration speed compounds. Each cycle teaches you more about your market, your users, and your path to scale.
Speed is also a lifesaver in a crisis. Like when Agri-iO’s key component was discontinued, they used Flux to design a custom solution in just a few days. Instead of facing months of delays, they had a working prototype in under a week, allowing them to fulfill a major contract and secure their supply chain. Read the full article.
“I used Flux to ask questions about which pins to connect and to get examples for specific designs. It suggested components and configurations. Flux reduced the amount of review work needed, and overall, it was a wonderful experience.” – Michael van Niekerk, Co-Founder and Head of Technology, Agri-iO
{{underline}}
Every great hardware company eventually realizes it is not just building a device. It’s building a system, the user, the problem, the workflow, and the feedback loop that connects them.
When evaluating your idea, it’s crucial to consider more than just the feasibility of building it. Instead, think about these key questions:
Hardware will always require patience, but the leverage has changed. Intelligence is spreading into the physical world, with the tools to design and test now open to everyone. The cost of curiosity has never been lower.
If you have an idea that keeps you up at night, now is the time to build it.
A decade ago, hardware design was fragmented and slow. Now, the ecosystem is built for speed.
Tools like Flux let teams design circuits in the browser, simulate instantly, and collaborate in real time. You can go from concept to a tested board in days. Prototyping services deliver parts overnight. The bottleneck is no longer the tooling; it’s how clearly you define what to test next.
The frontier isn’t in the cloud anymore. It’s in your hands. For anyone with an idea that keeps them up at night, the tools are finally ready for you.
Don't just build faster, learn faster. Start bringing your idea to life at flux.ai
{{start-designing-with-flux-ai}}
This guide helps you choose the best hardware platform—Arduino, Raspberry Pi, ESP32, or others, by comparing power, connectivity, and scalability for your project.
In this post, we’ll break down the most well-known platforms and how to decide which fits your project best.
Key considerations before choosing a board:
If you’re not sure which board to choose, Flux’s AI can help. It understands these platforms and trade‑offs. Describe your project in plain language and it will ask clarifying questions, compare options, and even suggest components and reference designs based on your needs.Flux’s AI can:
Try asking Flux’s AI:
“I want to build a battery‑powered temperature logger that sends data over WiFi. Which board should I use?”
Try it now
“Compare ESP32 and Raspberry Pi Pico for a low‑power wearable that needs Bluetooth.”
Try it now
“Help me design a prototype around Arduino Nano that could scale to a custom PCB later.”
Try it now
“Which microcontroller would be best for a small robot that needs real‑time motor control and wireless communication?”
Try it now
The AI will walk you through the decision, suggest parts and generate a starting design file you can modify.
{{start-designing-with-flux-ai}}
{{underline}}
Arduino is a microcontroller-based platform known for its simplicity and approachability. Boards like the Arduino Uno are ideal for real-time tasks such as reading sensors or controlling LEDs. You write code in C/C++ using the Arduino IDE, and it runs directly on the hardware without the need of an operating system.
Pros
Cons
Best for
One example project is SmokeSensor Shield which used to monitor chimney smoke and provide feedback to stove.
The Raspberry Pi is a full Linux computer in a small form factor. It can run Python, connect to a monitor, and handle USB peripherals, ideal for complex prototypes, especially when you need a GUI, internet access, or heavier processing like image or audio.
Pros
Cons
Best for
Raspberry Pi has many use cases, including this Pico Smart Automation Controller project which enables intelligent control for sensors, relays, and devices.
The ESP32 strikes a balance: it’s a 32-bit dual-core microcontroller with built-in Wi-Fi and Bluetooth. It has much more power than Arduino but doesn’t run an OS like the Pi. It’s great for IoT applications where you want connectivity, battery efficiency, and scalability.
Pros
Cons
Best for
The ESP32 is one of the more widely known microcontroller, so that means you can find from the simplest to more advanced projects and templates, like these Dual Ultrasonic Water Level Monitoring System and ESP32 Robot Controller project.
Particle combines hardware and cloud into one platform. You get microcontroller boards with built-in connectivity (Wi-Fi, LTE, etc.), plus tools for remote management, firmware updates, and data collection, all managed via Particle Cloud.
Pros
Cons
Best for
Particle has their own great specific use cases, and this Robo project gives you a great idea where to start.
BeagleBone boards are Linux-capable computers like Raspberry Pi but with a focus on industrial use and I/O. Boards like the BeagleBone Black have built-in PRUs (real-time units) and tons of GPIO—perfect for robotics, automation, or anything requiring lots of sensors.
Pros
Cons
Best for
Beyond the “big names” above, here are several other hardware platforms and ecosystems that a small hardware startup might consider, each with niche strengths:
{{underline}}
Ultimately, there’s no one‑size‑fits‑all answer. The “best” platform depends on your project’s unique requirements and constraints. As a small hardware startup founder, you want to maximise development speed and flexibility while ensuring a viable path to scale. Here are some guideline decision‑paths:
Ready to pick a platform and start building? Open Flux, create a new project and ask the AI to help you choose a board. From there you can explore component options, generate schematics and iterate quickly — all without leaving your browser.
{{start-designing-with-flux-ai}}
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.
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 engineering intern. With the right direction, 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:
This workflow allows you to move fast while keeping control. The sections below walkthrough how to write great prompts.
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
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.
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.
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”.
After helping hundreds of users in the Flux Slack 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:
The earlier you correct course, the faster you get to a working design.
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:
Flux is rapidly growing its AI capabilities to support:
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 engineering intern you’ve always wanted—fast, reliable, and just a prompt away.
