Why I Built a News Monitoring AI (and Why I Didn’t Turn It Into a Product)

I built Newsmon as a simple idea:

Monitor a set of sources, filter for relevance, and send me only the stories I care about.

At the time, it was a good way to explore GCP, LLMs, and what people now call “AI agents”. It did exactly what I needed — and it helped me land an AI role.

But I didn’t turn it into a product.

This is why.

The idea was straightforward

The initial version looked like this:

• pull content from feeds (RSS, sites)
• extract and clean the text
• run it through an LLM for:
  • summarisation
  • relevance filtering
• send alerts (originally via WhatsApp)

It worked surprisingly well early on.

You can get something like this running in a few days now.

The first problem: relevance is fragile

At small scale, it feels like magic.

You define a prompt like:

“Only show me important FX or macro stories”

And it mostly works.

But over time, things drift:

• stories start slipping through that aren’t useful
• genuinely important ones get missed
• the definition of “relevant” subtly changes depending on context

You end up in a loop of:

• tweaking prompts
• adding rules
• second-guessing outputs

The system doesn’t break — it just becomes less useful.

That’s worse.

The second problem: noise creeps in slowly

Even with good filtering, volume builds up.

• one source becomes five
• five becomes twenty
• each one slightly different in quality

LLMs will happily summarise everything you give them.

They don’t solve the core problem:

deciding what not to process

So you either:

• accept more noise
• or spend time constantly tuning filters

Neither scales well.

The third problem: users make it harder

It worked for me because:

• I knew what I cared about
• I could adjust the system quickly

Turning it into a product means:

• user preferences
• different definitions of “important”
• delivery expectations (real-time vs digest)

Now you’re building:

• profiles
• storage
• feedback loops
• UI to control it

At that point, it’s no longer a simple system.

It’s a full product with ongoing complexity.

The fourth problem: delivery is not trivial

Sending summaries sounds easy.

It isn’t.

• timing matters
• batching vs real-time matters
• channels matter (email, app, messaging)

WhatsApp was the original goal.

That introduced a specific constraint:

messages can’t be sent freely outside a 24-hour window without using pre-approved templates

This breaks a key assumption.

A monitoring system needs to:

• send updates when something matters
• not just when a user has recently interacted

Working around this means:

• managing templates
• handling approval flows
• or redesigning delivery entirely

At that point, it becomes a platform constraint, not just an engineering problem.

Alongside that, you still have:

• API constraints
• formatting challenges
• reliability concerns

It becomes an integration problem, not just an AI one.

What actually worked

Despite all that, a few things were genuinely valuable:

1. LLM summarisation is very strong

Given clean input, you get:

• consistent summaries
• good compression of information
• usable outputs immediately

This part is solved well enough.

2. Simple pipelines beat complex agents

The best version of Newsmon wasn’t an “agent”.

It was:

• ingest
• filter
• summarise
• deliver

Clear steps. No autonomy. No looping.

More predictable. Easier to debug.

3. Constraints matter more than prompts

The biggest improvements came from:

• limiting inputs
• structuring outputs
• adding basic validation

Not from writing more elaborate prompts.

Why I didn’t turn it into a product

It comes down to this:

Getting signal is easy. Maintaining it is the hard part.

To make Newsmon a real product, I’d need to invest in:

• continuous tuning of relevance
• user-specific customisation
• delivery infrastructure
• monitoring and support

That’s a separate startup.

At the same time, I was already running production systems elsewhere and had just moved into an AI role.

The opportunity cost didn’t make sense.

What I took from it

Newsmon did exactly what it needed to do:

• helped me understand real-world AI pipelines
• exposed where LLMs work well (and where they don’t)
• reinforced that most problems are still system design problems

Not model problems.

Where it sits now

Newsmon isn’t a product.

It’s an experiment and a reference point.

A simple system that:

• monitors sources
• summarises content
• demonstrates the core patterns

That’s enough.

The broader takeaway

A lot of AI ideas look like products at first.

Many are better understood as:

useful internal systems with high maintenance costs

The difference matters.

Because building something that works once is easy.

Building something that stays useful is not.