Introduction

Adopting a new tool in an existing codebase is always a balancing act.

You want immediate value—but without disrupting what already works.

That’s especially true with AI tools. If they don’t understand your system, they create more noise than signal.

Flames is designed differently.

Instead of forcing you to adapt your workflow, Flames adapts to your codebase—starting with deep understanding before any code is generated.

This guide will walk you through how to get started quickly and effectively.

Step 1: Connect Your Repository

The first step is simple:

• Link your repository to Flames

• Grant read access (and write access if needed)

Once connected, Flames begins indexing your entire codebase.

What Happens During Indexing

Flames analyzes:

• File structure and organization

• Module relationships

• Dependency graphs

• Shared utilities and patterns

This step is critical—it’s what enables everything that follows.

Step 2: Let Flames Learn Your Codebase

Unlike traditional tools, Flames doesn’t jump straight into generation.

It first builds a map of your system.

Why This Matters

Without this step, AI operates blindly.

With it, Flames can:

• Reference the right files

• Reuse existing logic

• Follow your architectural patterns

Think of it as onboarding a new engineer—except it happens automatically.

Step 3: Start with Small, Contextual Tasks

Don’t begin with a massive feature.

Start small.

Good First Tasks

• Add a minor endpoint

• Refactor an existing function

• Extend a component

• Fix a bug

These tasks help you:

• Validate output quality

• Understand how Flames interprets your codebase

• Build trust in the system

Step 4: Use Natural, High-Level Prompts

Because Flames already understands your codebase, you don’t need to over-explain.

Instead of:

“In our React app using Redux Toolkit, following our async thunk pattern…”

You can say:

“Add a new user fetch flow similar to existing ones.”

Flames fills in the context automatically.

Step 5: Review and Iterate

Even with strong context, review is essential.

What to Look For

• Does the code follow your conventions?

• Is it using the right abstractions?

• Does it integrate cleanly?

If something feels off, refine your prompt and try again.

Flames improves with iteration.

Step 6: Expand Scope Gradually

Once you’re confident, increase complexity:

• Build larger features

• Modify multiple modules

• Introduce new flows

Because Flames understands dependencies, it can handle changes across your system—not just isolated files.

Step 7: Integrate into Your Workflow

Flames works best when it’s part of your daily development loop.

Recommended Workflow

1. Define what you want to build

2. Prompt Flames

3. Review generated code

4. Run tests and validate

5. Ship

Over time, Flames becomes a natural extension of your team.

Common Pitfalls to Avoid

1. Skipping Indexing

If Flames doesn’t fully understand your codebase, results will suffer.

Let indexing complete.

2. Starting Too Big

Jumping into complex features too early makes it harder to evaluate output.

Start small, then scale.

3. Over-Specifying

You don’t need to describe everything—Flames already has context.

Focus on intent, not implementation details.

What Success Looks Like

When Flames is set up correctly, you’ll notice:

• Less boilerplate code writing

• Faster feature development

• Fewer integration issues

• Code that “just fits” your system

That’s the difference context makes.

Final Thoughts

Introducing AI into an existing codebase doesn’t have to be disruptive.

With the right approach, it can be seamless—and transformative.

Flames works because it starts where most tools don’t:

Understanding your system before trying to change it.

Great tools don’t force you to adapt.
They adapt to you.

And that’s exactly how Flames gets started.