Why does my AI coding agent keep suggesting things I've already rejected?

AI coding agents have no memory of past decisions. Each session starts fresh. When you reject an approach, that information isn't stored anywhere the AI can access in future sessions. Without decision history, the AI will keep suggesting the same rejected approaches.

How do I stop my AI coding assistant from making the same mistakes?

Give your AI access to persistent product context via MCP. Brief stores your decisions, rejected approaches, and rationales. When your AI suggests something, it can check Brief first to see if you've already made a decision about that approach.

Why does Cursor/Claude keep suggesting the wrong patterns?

AI coding tools suggest patterns based on general best practices, not your specific constraints. They don't know about your architectural decisions, customer requirements, or rejected approaches. With product context from Brief, AI can align suggestions with your actual decisions.

Why Your AI Coding Agent Keeps Making the Same Mistakes

The Frustrating Loop

You've been here before. You ask Cursor to implement a feature. It suggests using GraphQL. You explain that you're using REST and why. It accepts this, adjusts its approach, and you move on.

Next session. Same request. Same GraphQL suggestion. Like the conversation never happened.

┌─────────────────────────────────────────────────────┐ │ The Rejection Loop │ │ │ │ Day 1: AI suggests GraphQL → You reject, explain │ │ ↓ │ │ Day 2: AI suggests GraphQL → You reject again │ │ ↓ │ │ Day 3: AI suggests GraphQL → Frustration mounts │ │ ↓ │ │ Day N: Still suggesting GraphQL... │ └─────────────────────────────────────────────────────┘

This isn't a bug in the AI. It's a fundamental architectural limitation.

Why This Happens

1. No Decision Memory

AI coding assistants don't store your decisions. When you reject an approach, that information exists only in the current session's context window. Tomorrow, it's gone.

2. Generic Training, Specific Needs

Your AI was trained on millions of codebases. GraphQL is popular. GraphQL solves common problems. So the AI suggests it. But your constraints are unique, and the AI doesn't know them.

3. Context Windows Are Finite

Even if you paste your decisions into every session, context windows have limits. Important decisions from early in the conversation can fall out as the session continues.

The Real Cost

Every time you re-explain a decision, you're spending cognitive energy on something you already solved. Multiply this across dozens of decisions, and you're spending hours per week on repetition instead of building.

Common Mistake Patterns

The Rejected Approach Loop

AI suggests an approach you've explicitly rejected. You explain why. Next session, same suggestion.

"Let's use MongoDB here..." (You chose Postgres weeks ago.)

The Wrong Customer

AI builds for generic users instead of your actual ICP. Features don't match customer needs.

"Users will want real-time collaboration..." (Your users are solo founders.)

The Duplicate Feature

AI suggests building something that already exists elsewhere in your codebase.

"Let me create a utility function for..." (You have one in /utils.)

The Wrong Pattern

AI uses architectural patterns that don't fit your established conventions.

"I'll use Redux here..." (Your app uses Zustand everywhere else.)

The Fix: Persistent Decision Memory

The AI needs access to your decisions, not just your code. When it suggests an approach, it should check: "Has the team already decided about this?"

With Brief

When your AI suggests GraphQL, it can query Brief first and discover: "We decided to use REST for simplicity (Decision #34). Rationale: smaller team, simpler debugging, no need for flexible queries." The AI adjusts before you have to correct it.

How It Works

Record decisions as you make them. "We're using Postgres because of relational data needs." Brief stores this with rationale.

AI queries before suggesting. Your coding assistant checks Brief for relevant decisions before proposing approaches.

guard_approach validates plans. Before major changes, AI runs Brief's guard_approach to check for conflicts with existing decisions.

Context persists across sessions. Tomorrow's session knows what today's session decided.

Frequently Asked Questions

Can't I just use a rules file like .cursorrules?

Rules files help with coding conventions but don't capture decision history. You can write "use REST not GraphQL" but not "we rejected GraphQL because of X, Y, Z in the context of feature A." Brief stores the full decision with rationale, making it searchable and contextual.

How does the AI know to check for decisions?

Brief connects via MCP (Model Context Protocol). AI tools like Cursor and Claude Code can query Brief as a tool call. When you ask about a topic, the AI can search Brief for relevant decisions before responding.

What if I change my mind about a decision?

Update or archive the decision in Brief. The AI will see the new decision and adjust. Decision history is preserved so you can see what changed and why.