Teach Copilot How You Work with Knowledge

That’s why we built Copilot Knowledge: a way to offload your internal mental graph into something persistent, reliable, and AI-accessible. Now, Flux Copilot can learn how you work—your design principles, part selection preferences, schematic, and testing workflows—and remember them automatically.

It’s like onboarding a new teammate who can understand and distill your process, catches inconsistencies, and applies the right context when you both need it. But this isn’t just memory—it’s leverage. Copilot uses its knowledge to improve its suggestions and take smarter actions helping you move faster with fewer mistakes.

And the best part? You don’t have to change the way you work. Just talk to Copilot as you normally would. When it detects a relevant insight, it’ll ask if you want to save it. Approve what matters, and your personal or project-level Knowledge base builds naturally over time. Let’s dive in!

What is Copilot Knowledge?

Knowledge is persistent memory for your Copilot. It stores reusable instructions, tribal knowledge, and workflow guidance that help Copilot work more like you do.

You can teach Copilot anything that improves its judgment across tasks:

• Part selection criteria like preferred manufacturer, quantity of scale, package and case, and more.
• Naming conventions of nets and components for when copilot takes action
• The review and testing checklists that you use in every design
• Design rules and style guidelines for schematics. Think derating, decoupling preferences, etc.

Each Knowledge entry includes:

• A summary of your instruction
• The trigger (what type of task it applies to)
• Whether it’s tied to you or a specific project

This means Copilot can tailor its help based on your intent and context—not just the immediate task at hand.

How Copilot Knowledge works

As you chat with Copilot, it now looks for teachable moments. If you say something like:

“Always use TI parts for voltage boosters” or
“Start every layout with DRC checks”

Copilot will offer to turn that insight into a reusable Knowledge entry.

You can accept, reject, or refine it. Once accepted, it becomes part of Copilot’s working memory. And the next time you’re designing a similar circuit, it’ll know to apply that guidance without being asked.

You can also manually add entries from your profile or project settings. Every Knowledge entry you create makes Copilot smarter and more aligned with how you think.

Project vs. Personal Knowledge

Every time you save a piece of Knowledge, you can decide where it should apply: just to this project, or to everything you work on going forward.

If you choose project-level, Copilot will only use that Knowledge within the specific project it was saved in. This is ideal for capturing things like client-specific standards, board-specific constraints, or one-off decisions that aren’t relevant elsewhere.

If you choose user-level, Copilot will use that Knowledge across all your future designs. This is where you’ll save broader design habits—like how you label nets, the parts you tend to default to, or your general approach to testing.

Scoping Knowledge like this keeps Copilot flexible. It lets you define reusable standards when it makes sense and isolate exceptions when needed—just like you would when explaining something to a junior engineer stepping into a new design.

Onboard Copilot Like a New Teammate

Getting the most out of Copilot Knowledge is a lot like onboarding a new hire. The more context you give early on, the more independently—and accurately—they’ll be able to contribute.

When Copilot suggests saving a Knowledge entry, it's your opportunity to share something you’d normally explain to a colleague joining the project for the first time. That might be a naming convention you always use, a preferred component vendor, a filter that’s worked well in the past, or a key review step you never skip. These kinds of insights are rarely documented—but they’re essential to maintaining quality and consistency in real designs.

To get started, we recommend:

• Reviewing any auto-generated Knowledge entries for clarity and accuracy
• Editing or expanding entries to reflect your actual workflow
• Choosing the right scope (user vs. project) based on how broadly it should be applied

You don’t need to front-load everything. Knowledge builds naturally over time. But with just a little intentional input, Copilot becomes a design partner who doesn’t just follow your lead—it understands how you lead, and why.

Start Using Knowledge Today

Copilot Knowledge is available now, and there’s nothing new to learn to start using it. Just keep working the way you already do. As you chat with Copilot, it will surface patterns and insights you’ve taught it—then offer to save them as reusable Knowledge.

Start with something simple. A naming convention you always use. A go-to part family. A review checklist. Save that, and keep going. Over time, your Knowledge base grows with you—project by project, decision by decision—until Copilot starts feeling less like a tool and more like a teammate who’s been working with you for years.

This is how design becomes more scalable, more consistent, and more collaborative—without slowing you down.

{{open-flux-start-teaching-copilot}}