Why We Built Pull PM: An AI That Actually Learns From Its Mistakes

You've probably heard the pitch a hundred times: "AI will change everything." And maybe you've even tried working with AI assistants on real projects. Sometimes it's magic. Sometimes it confidently breaks everything. And the frustrating part? It makes the same mistakes again and again.

That's why we built Pull PM.

The Problem Nobody Talks About

Here's what happens with most AI coding assistants: You ask it to do something. It tries. It fails. You explain what went wrong. It tries again. Eventually, you get it working.

Then next week, you ask it to do something similar. And it makes the exact same mistakes.

Why? Because most AI assistants have no memory. Every conversation starts fresh. All those lessons learned? Gone. You're back to square one, re-explaining the same nuances, watching it make the same errors, burning the same hours.

We thought: what if the AI could actually learn from each project and carry that knowledge forward?

Enter the Learning Loop

Pull PM is built around a simple idea we call the "Ralph Wiggums Loop" (yes, named after that Ralph Wiggums - because sometimes you have to try, fail, and try again before the lightbulb clicks).

Here's how it works:

Understand - Read the task and what "done" looks like

Attempt - Take a shot at completing it

Validate - Check if it actually worked

Learn - If it failed, capture why and try again

Document - When it works, write down what we learned

The magic is in that last step. Every lesson gets saved to a "learning file" specific to that client or project. Next time Pull PM encounters something similar, it reads those notes first.

It's like giving the AI a notebook that it actually uses.

A Real Example: The Spreadsheet That Fought Back

Let me show you what this looks like in practice. We recently had a client who needed to modify a complex Smartsheet - think of it as a spreadsheet on steroids with formulas, linked cells, and intricate row structures.

The task seemed simple: expand each 5-row group into a 10-row group. Add 5 new rows, copy some formulas, done. Right?

Attempt 1: Confident and Wrong

Pull PM analyzed the sheet, saw that each group started with a special "header row," and logically decided to insert the new rows right below that header.

Result: Disaster. Inserting below row 1 pushed all the existing rows down, breaking the entire structure. The client's carefully organized data was scrambled.

Lesson captured: "Insert at END of group, not beginning."

Attempt 2: Better, But Missing Something

Okay, new approach. Insert at the end of each group. The structure stayed intact this time. Progress!

But when we checked the results, one critical column was completely blank. The formula that should have been copied... wasn't there.

Lesson captured: "Reference column needs formula =[Reference]$[header_row], not empty."

Attempt 3: Formula Fixed, Ready to Test

Pull PM added the formula pattern. But here's where it got smart - instead of running on the whole sheet (800+ rows), it ran a "pre-flight test" on just 3 groups first.

Everything looked good. But we'd been burned before, so we tested on a copy of the sheet, not the real one.

Attempt 4: Test Sheet Success

81 groups processed. 405 rows inserted. Every formula correct. Every value in place.

Lesson captured: "Always test on copy first. Pre-flight with 3 groups catches most issues."

Attempt 5: Production Success

With confidence from the test run, we hit the production sheet. Same results: 81 groups, 405 rows, zero errors.

Total attempts: 5. Total lessons learned: 4 major insights, plus a dozen smaller notes about API quirks, rate limits, and column types that can't be edited.

The Part That Matters

Here's the thing: the client originally estimated this task would take 5-6 hours of manual work - analyzing the sheet structure, figuring out the patterns, carefully inserting rows one group at a time, fixing mistakes along the way.

Instead, we spent about 3 hours building and testing the Pull PM workflow. Yes, it took 5 attempts. Yes, there was trial and error. But here's what we have now:

A learning file that documents:
• The exact structure of this client's sheets
• Which columns have formulas that can't be touched
• The correct order of operations for row insertion
• The testing protocol that catches problems early

Next time this client needs the same operation? It'll take minutes, not hours. And next time any client has a similar sheet structure, Pull PM already knows the patterns to look for.

The AI learned. For real.

Meta Moment: This Blog Post Proves the Point

Here's something worth noting: the story I just told you? I didn't have to remember it. Pull PM wrote this blog post by reading its own learning files.

The task documentation captured every attempt, every failure, every lesson. When we asked Pull PM to write about why it exists, it pulled from those records and reconstructed exactly what happened - the wrong insert position, the missing formula, the pre-flight test that saved us.

That's the whole point. The knowledge isn't trapped in someone's head or lost in a chat history. It's documented, searchable, and reusable. Pull PM can reference its own experiences to explain them, improve on them, or apply them to new situations.

The learnings don't just help with future tasks. They become the source material for everything - documentation, blog posts, client reports, you name it.

Why This Matters for Vibe Coders

If you're building things with AI but don't have a traditional engineering background, this is huge. You don't have years of experience to draw from when things go wrong. You're learning alongside the AI.

Pull PM is designed for exactly this situation:
• It documents what it learns so you don't have to remember everything
• It tests before it touches production because mistakes are expensive
• It gets smarter on YOUR specific projects not just general knowledge

Think of it as an AI assistant that takes notes, remembers what worked, and actually reads those notes before starting the next task.

The Bigger Picture

We're not claiming Pull PM is perfect. It still makes mistakes. It still needs human oversight. (Those pre-flight tests exist for a reason.)

But it's moving in the right direction: AI that accumulates knowledge over time, specific to your work, your clients, your weird edge cases that no general-purpose assistant would ever know about.

The spreadsheet task that took 3 hours to figure out? Next time it'll take minutes. The 5-6 hour manual estimate? We beat it on the first run, and every future run is essentially free. And as Pull PM reads more learning files, it starts anticipating problems before they happen.

That's the future we're building toward. Not AI that's impressive in demos but forgetful in practice. AI that actually gets better the more you work with it.

---

*Pull PM is an autonomous product manager and engineer built for vibe coders and entrepreneurs. It completes tasks, learns from each one, and carries that knowledge forward. Want to see it in action?