If you haven’t installed the Temboo Agent yet, start there first.

This post is about what you should do next. More specifically, it’s about how to spend your first 15 minutes with the Temboo Agent so that you can see value as quickly as possible. The goal isn’t to learn everything that the agent can do, but rather to get a feel for how it can help you without wasting any of your time.

What to expect in the First 15 Minutes

The Temboo Agent lives inside VS Code and is designed to work alongside you as you develop embedded systems. It’s not designed to replace how you work, but rather to give you a more productive way of accessing documentation, debugging issues, writing code, and more. It can do a lot, but in the first few minutes, early users have told us that the most valuable thing to do is to ask the agent to explain something that they’re already at least somewhat familiar with. This is a great way to sanity check the agent and get a feel for how it works.

You should think of the agent as an experienced engineering colleague who is always happy to answer your questions and take on new tasks. You probably wouldn’t assign real work to someone without first getting a feel for what they know.

Three High-Value Things To Try Right Away

You can do an endless number of things with the agent, but based on early user feedback, here’s the three things that will help you get a feel for how it works and see value quickly.

1. Have the agent explain some real code

This is the single best place to start.

Use the Add Context feature to share a source file (or a small set of files), and ask the agent to explain what’s going on. Here’s an example prompt:

I’ve uploaded this file from an nRF Connect project. Can you explain what this file is responsible for and anything that might be non-obvious to a developer new to this code? Thanks!

This is especially useful for:

• Getting to grips with vendor example projects that you didn’t write (as shown in the gif above)
• Refreshing your memory about code that you’re returning to after some time away
• Understanding code that was written by a colleague that you’re either reviewing, collaborating on, or taking over

What you’re not doing right now is looking for the agent to help your refactor the code or generate new code. You’re simply getting a sense of the agent’s capabilities and gaining an understanding of how it performs on a task that you’re in a good position to evaluate.

2. Ask it to help you reason about a common pain points

Once you’ve seen it explain your own code, I recommend that you move on to exploring one of the areas in which embedded developers often lose time – configuration issues. Examples of good things to ask the agent about in this area include:

• Why a build might work but yet the board doesn’t boot
• How a particular config setting influences runtime behavior
• Common causes of failure when attempting to enable a peripheral on a specific microcontroller
• How hardware your config choices affect generated code and drivers

Good prompts aren’t curt demands like “fix this for me”, but rather, they are complete questions that get to the heart of the issue at hand. Here’s an example prompt targeting a config issue:

My code builds successfully, but the board doesn’t behave as expected at runtime. Based on typical projects using the same SDK, what are the most likely things I should check first?

The agent is particularly good at acting as a tutor and helping you understand toolchain relationships. And even when the agent doesn’t give you an immediate answer to a complex problem, it can help you quickly rule out dead ends and really focus your debugging process. It’s best to think of your relationship with the agent as collaborative and iterative, rather than as you handing over control and giving up responsibility.

3. Use it to quickly orient yourself

A final high-value task for your first 15 minutes is to explore how the agent can help you understand pretty much anything about the hardware platform that you’re using. We’ve heard from early users that they are turning to the agent in cases where they might previously have searched documentation or gone to forums. The agent is designed to be good at helping you get a sense of things like:

• What a given file or set of files is doing
• What parts of your chosen SDK are involved in a specific feature
• Where a certain config value is coming from and why it’s there
• What changes between SDK versions are important for a given project
• And lots more…

This is especially useful when context-switching or trying to get familiar with a new codebase. The agent can help you get a quick understanding of what’s going on, what’s important, and what your next prompt should be, so that you can continue to explore together.

A Note on Prompting

As mentioned earlier, the Temboo Agent works best when you treat it like a senior embedded developer who is always happy to answer your questions and execute your requests. This means that giving the agent as much information as possible via your prompts will yield the best results.

A few simple guidelines when writing prompts:

• Ask for explanations, things that you should check on, and common failure scenarios for the hardware and software components that you’re using (don’t just say “this is broken!”)
• Provide enough context to be useful, but not so much that you distract from the issue you care about (like a human, the agent can be overwhelmed by too much information)
• Don’t blindly trust generated code – use it to inform your thinking, test it rigorously, and ask the agent to check it too

The main thing to remember is how best to frame the relationship between you and the agent. You’re in control, and the agent is there to help you think clearly and be more productive.

Ready to Get Started?

If you haven’t already:

1. Sign Up for a Temboo account
2. Install the Temboo Agent in VS Code (read the Getting Started Guide)
3. Open the agent inside a project
4. Start by asking it to explain some code you’re familiar with

From there, dig deeper in the ways outlined above. There’s a lot that the agent can help with, and the best way to discover that for yourself is by using it on real problems you already have.

As you work with the agent, there may be embedded development workflows that you think the agent could do a better job on. If so, we’d love to hear about them! Please don’t hesitate to get in touch.