Project Intelligence

Team Performance & Collaboration

Back button

Ideas, Specs, and Acceptance Criteria

Reading time 4 min

Three new features that make product development more human, better organized, and far more precise.

Complexity has a funny way of sneaking into everything we do.

We start with good intentions. We create processes, add fields, introduce tools, and before we know it, something that should have been simple becomes unnecessarily complicated.

And now, with AI agents entering the product development lifecycle, we’re seeing a whole new category of problems.

Over the past few weeks, we’ve introduced three features in Project Simple to address some of these challenges. Each came from observing how teams actually work, where things break down, and how AI is changing the equation.

Here’s the story behind them.

 

Ideas deserve their own space

Let’s start with something that happens in almost every organization.

Someone has an idea. Maybe it’s a developer who spotted an opportunity while fixing a bug. Maybe it’s someone in support who keeps hearing the same customer complaint. Or maybe it’s a designer who thinks there’s a better way to solve a problem.

What happens next?

Sometimes they create a backlog item.

Other times, the idea ends up in a spreadsheet, a Slack conversation, a shared document, someone’s personal notes, or gets mentioned in a meeting and promptly forgotten.

Great ideas get scattered across the organization, with no central place to collect, discuss, or evaluate them.

And those that do make it into the backlog often sit there for weeks, months, or even years.

They never quite make it to the top because there’s always something more urgent. Eventually, the backlog becomes a graveyard of good intentions, filled with hundreds of items nobody remembers creating and nobody wants to delete.

Meanwhile, potentially valuable ideas disappear into the digital abyss, never to be seen again.

We wanted to give ideas a better home.

So we introduced Ideas in Project Simple.

A dedicated space where anyone, regardless of role, can contribute suggestions, share feedback, and participate in improving the product.

Ideas can be discussed openly, challenged, refined, and evaluated with input from the people closest to the problems. Teams can collect feedback to understand which suggestions resonate most and where the greatest potential impact lies.

And when an idea is ready to become actual work, it can be moved into the delivery process and tracked throughout its implementation from inception to production.

This accomplishes two things we care deeply about: keeping the backlog focused and giving everyone a voice in shaping the product.

After all, some of the best product improvements come from people who never attend a roadmap planning meeting.

 

AI slop has entered the backlog

This next one came directly from our experience working with MCP and AI agents.

As we made it easier for AI assistants to interact with Project Simple, something became painfully obvious.

AI can generate an incredible amount of text. Unfortunately, a lot of it is, for the lack of the better word, garbage.

Technically correct garbage, perhaps. But garbage nonetheless.

Long descriptions, elaborate language constructs, nested explanations, and enough bullet points to make your eyes bleed.

You ask an agent to create a backlog item, and suddenly you’re reading something that looks like a 12-page technical proposal for changing the color of a button.

Some of that information is useful. Agents need details, instructions, constraints, and technical context to do their work.

But humans need something different.

When someone opens a backlog item, they should be able to understand the problem in seconds. What are we solving? Why does it matter? What outcome are we trying to achieve?

Nobody should need another AI agent to summarize what the first one wrote.

So we made a change.

We separated Description from the Specs.

The Description is now the place for a simple, clear problem statement. Plain language. Something a five-year-old could understand. No unnecessary technical jargon, no walls of text, no AI-generated essays.

The Specs have their own dedicated space.

That’s where the technical details belong. The implementation approach, constraints, agent instructions, and all the information fleshed out during technical discussions about how the work should be done.

This separation is especially important as we move further into AI-DLC.

Agents can exchange detailed technical information without turning the human-facing description into an unreadable mess.

Developers can get the implementation details they need. Product managers and stakeholders can understand the problem without digging through technical noise.

Both get what they need, without getting in each other’s way.

And that matters more than ever as AI generates an increasing share of our development artifacts.

 

Acceptance Criteria: Let’s stop dropping the ball

Now for the third change.

We’ve always been able to write acceptance criteria inside backlog item descriptions. Most tools work that way.

But that approach has a fundamental problem.

When acceptance criteria are buried in paragraphs of text, they’re easy to overlook, hard to manage, and even harder to verify.

And we’ve seen the consequences plenty of times.

A feature gets implemented. The code looks good. The developer marks the work complete. QA gives it a pass.

Then someone notices that one of the requirements was missed.

Nobody intentionally ignored it. Nobody was being careless. It simply got lost somewhere between the original request, implementation, and validation.

With AI agents doing more of the implementation, the consequences can be even greater. An agent might produce perfectly functioning code that misses a critical requirement because the expected outcome wasn’t explicitly defined or validated.

So we gave Acceptance Criteria their own dedicated place on every backlog item.

Each criterion can be explicitly outlined, managed, tracked, and checked off.

Instead of hoping that everything mentioned in a description was implemented correctly, teams can verify completion against specific, measurable expectations.

This is about precision.

If something needs to be done, we should be able to define exactly what done means and verify that we achieved it.

No ambiguity. No assumptions. No accidental omissions.

Because discovering a missing requirement after delivery costs a lot more than getting it right the first time.

Bringing some sanity to AI-driven development

There’s a bigger picture behind these changes.

AI is making it dramatically easier to generate code, documentation, requirements, and entire implementations.

But generating more work, faster, doesn’t necessarily mean we’re building better products.

In fact, without the right structure, AI can amplify the same problems we’ve struggled with for decades: bloated backlogs, unclear requirements, miscommunication, and incomplete delivery.

That’s why we’re building Project Simple around a Product Operating Model for AI-DLC, with people firmly in control.

Ideas give everyone an opportunity to contribute without overwhelming the backlog.

Specs give humans and AI agents the technical depth they need without sacrificing clarity.

Acceptance Criteria make the expected outcomes explicit and verifiable.

The goal is simple: keep human communication simple, give AI the detail it needs, and make sure the work actually delivers what was intended.

Because at the end of the day, nobody gets paid for generating more tickets, writing longer descriptions, or producing more code.

We get paid for delivering better products.

And that’s what we’re building Project Simple to help teams do.

Success Icon

Your message has been sent!

Thank you for reaching out! We have received your message 
and will get back to you soon.

Success Icon

Your message has been sent!

Thank you for reaching out! We have received your message 
and will get back to you soon.