About a year ago I made a dumb commitment to myself: build one Claude AI agent or skill per week, every week. Not blog about it. Not make YouTube videos about it. Actually build working things and put them on GitHub.

I've been doing product management for 30 years — launched over 115 products across my own companies and consulting work. I figured if I'm going to have opinions about AI in product, I should probably understand how it actually works from the inside.

Some of what I built:

• LegalAnt : A Claude agent for legal teams. Contract review, clause extraction, compliance flagging. Built it because a client was paying a paralegal 3 hours a day to do work that took the agent 4 minutes. It's not perfect. It flags things conservatively and sometimes over-indexes on boilerplate. But it doesn't miss things, which is the actual job.
• Market Research agent: Structures competitive intelligence work. Maps categories, separates signal from noise, outputs evidence-graded research briefs. The grading part matters more than people expect. "Here's what I found" is useless. "Here's what I found, and here's how confident you should be in it" is actionable.

Most of these were small. Some were bad. A few I deleted and rewrote from scratch. That's the point.

Then I built Lumen, which is the big one.

Lumen is a Claude Code plugin. 18 agents. 6 end-to-end PM workflows. Runs entirely in your terminal.

Before anyone says yes to it, I know. "Another AI PM tool." I was skeptical of my own idea for a while. Here's what made me build it anyway.

Every AI PM tool I've tried has the same architecture: you talk to a chatbot, it gives you output, you paste more context, it gives you more output. You're doing all the coordination in your head. The AI is just autocomplete with better grammar.

What I wanted was something that could actually sequence work. You give it a problem, it figures out which agents need to run in which order, what data each one needs, and what decisions require a human before continuing. More like a junior analyst team than a chatbot.

Field Guide: appetals.com/lumenfieldguide ·

GitHub: github.com/ishwarjha/lumen-product-management

How it actually works:

You type something like:

/lumen:pmf-discovery

Product: [your product] Segments: [your user segments] Key question: D30 retention dropped from 72% to 61% over 8 weeks. Is this PMF regression, product quality, or both?

And it sequences:

• EventIQ validates your event schema
• SignalMonitor scores PMF by segment from PostHog data
• DiscoveryOS builds an opportunity tree from your signals
• MarketIQ maps competitive position
• DecideWell structures the final decision with evidence weighting

Every recommendation gets an HIGH / MEDIUM / LOW rating based on what data was actually available. If PostHog isn't connected, the PMF scoring step tells you that instead of hallucinating a number.

The part I'm most proud of and that sounds the most ridiculous:

Each agent is a Markdown file.

That's it. YAML frontmatter for config. Markdown sections for behavior. No compiled code. No proprietary framework. If you can write a good product spec, you can write a Lumen agent.

Agents talk to each other through named "context slots" — 51 of them defined in a single schema file. An agent either has the slots it needs or it blocks and says what's missing. This made debugging actually possible, which I did not expect.

What's broken / what I'd do differently:

• The setup experience is rough. Getting MCP servers connected requires patience and some comfort with config files. I'm working on this.
• 18 agents sounds impressive until you realize some of them are narrow enough that most workflows won't hit them. Enterprise tier agents especially.
• The evidence quality ratings are only as good as the data connected. Without PostHog, W1 is running on vibes with a label on them.
• I built this for Claude Code specifically. It won't work in Claude ai chat. That's a real constraint that I underestimated how much it would limit the audience.

Where it is now:

Free to start. MIT license. Open on GitHub.

I'll keep building one thing a week. Some weeks it's a small skill. Some weeks it's an agent. Occasionally something bigger. The goal was always to learn in public and share what works.

Happy to answer questions about the architecture, what broke, or why I made specific decisions. AMA basically.

TL;DR: You can search google and find out Lumen on Github. I will post the link in comments per sub rules if any member request.

I've been building one AI agent a week for about a year. My latest is a PM co-pilot with 18 agents. Here's what actually happened.

So about a year ago I made this commitment to myself — build one working Claude agent or skill per week. No blogging about it, no YouTube content mill stuff. Just build things, put them on GitHub, move on.

Quick context on me: I've been in product management about 30 years, launched something like 115 products between my own companies and consulting. I got tired of having opinions about AI in product without actually understanding how any of it works under the hood. So I started building.

Some of the stuff I shipped along the way:

LegalAnt — a Claude agent for legal teams. Does contract review, clause extraction, compliance flagging. Built it because I watched a client's paralegal spend 3 hours a day doing work the agent could do in 4 minutes. It's not perfect — it flags things too conservatively and sometimes freaks out about boilerplate language. But it doesn't miss stuff. And honestly for legal work that matters way more than being elegant about it.

Market Research agent — structures competitive intel work. The thing that actually makes it useful vs just throwing stuff at ChatGPT is the evidence grading. "Here's what I found" is basically worthless. "Here's what I found and here's how much you should trust it" is something you can actually make decisions with.

Most of what I built was small. Some of it was genuinely bad. I deleted a few and rewrote them completely. You learn more from the ones that suck.

OK so then I built Lumen. This is the big one and the one I actually want to talk about.

Lumen is a Claude Code plugin. 18 agents, 6 PM workflows, runs in your terminal.

Yeah I know. "Another AI PM tool." I sat on the idea for a while because I had the same reaction. Here's what finally pushed me to build it:

Every AI PM tool I've used has the same problem. You talk to a chatbot. It gives you output. You paste more context. It gives you more output. YOU are doing all the orchestration in your head. The AI is basically autocomplete with better vocabulary.

What I wanted was something that could actually sequence work on its own. You hand it a problem, it figures out which agents run in what order, what data feeds into what, and where it needs to stop and ask a human before continuing. Less "chatbot" and more "junior analyst team that actually follows a process."

How it works in practice:

You run something like:

/lumen:pmf-discovery
Product: [whatever]
Segments: [your segments]
Key question: D30 retention dropped from 72% to 61% over 8 weeks.
PMF regression, product quality issue, or both?

And then it chains through a sequence:

• EventIQ validates your event schema
• SignalMonitor scores PMF by segment using PostHog data
• DiscoveryOS builds an opportunity tree from those signals
• MarketIQ maps where you sit competitively
• DecideWell structures the final call with evidence weighting

Every recommendation gets a confidence tag — HIGH / MEDIUM / LOW — based on what data was actually available. If PostHog isn't connected, the PMF step says "hey I don't have data for this" instead of making up a number. Took me a while to get that right but it's important.

The part that sounds dumb but I'm actually proud of:

Each agent is literally a Markdown file. YAML frontmatter for config, markdown sections for behavior. No compiled code, no proprietary framework. If you can write a decent product spec you can write a Lumen agent. I didn't plan it that way, it just ended up being the simplest thing that worked and I never had a reason to make it more complicated.

Agents pass data through what I call "context slots" — there's 51 of them in a single schema file. An agent either has the slots it needs or it stops and tells you what's missing. This one decision made debugging 10x easier which I absolutely did not expect going in.

What's broken / what I'd redo:

Setup is rough. Getting MCP servers wired up takes patience and you need to be comfortable editing config files. Working on making this less painful but it's not there yet.

18 agents sounds cool in a headline but honestly some of them are narrow enough that most people won't ever trigger them. The enterprise tier ones especially — I built them for specific scenarios that don't come up unless you're at a certain scale.

The confidence ratings are only as good as your connected data. Without PostHog plugged in, workflow 1 is basically running on vibes and slapping a label on them. I'm upfront about this in the docs but it's still a limitation.

And the big one — I built this specifically for Claude Code. Won't work in Claude AI chat. I underestimated how much that would shrink the audience. Most people don't live in their terminal. Lesson learned, might address it later but no promises.

Where things stand now:

It's free, MIT licensed, open on GitHub. I'm going to keep doing the one-thing-a-week cadence. Some weeks it's a tiny skill. Some weeks it's an agent. Every now and then something bigger. The whole point was always to learn by actually building and share what comes out of it.

Happy to answer questions about the architecture, what went wrong, specific design decisions, whatever. Ask me anything.

tl;dr: been building AI agents weekly for a year, the latest one (Lumen) orchestrates 18 PM-focused agents through 6 workflows in Claude Code. It's on GitHub if you want to poke at it, will drop the link in comments if anyone wants it.