A few weeks ago I read an article about “poor man’s continuous learning” for AI agents. The core idea: instead of fine-tuning models, build a retrieval layer that accumulates structured knowledge. The model stays the same - the system around it gets smarter.

I don’t just read. I build.

The Research Agent

Built a research agent with Claude implementing this methodology:

  • Snapshots: each question saved with embedding for semantic search
  • Claims: distilled statements extracted from research, each with confidence score
  • Sources: provenance tracking for every claim

When a new question comes in, the agent searches for similar past questions, runs web research, extracts claims, compares new to existing. What’s new? What got stronger? What disappeared? Confidence updates, duplicates filter out.

Built a FastAPI interface to visualize the whole process.

Then took it further - created a /command for Claude Code applying the same methodology to our conversations. Extract insights, save to knowledge base, recurring insights strengthen.

Then Real Work Happened

Pure Blue Fish needed market research for Atlanta expansion. Not a demo - actual business decision material.

The process was complex. 8 phases:

  1. Define region - facility location + 4-6 hour delivery radius
  2. Collect restaurant data - Google Places API, deduplication
  3. Aggregate by city/state
  4. Population data - US Census Bureau, density calculations
  5. Pricing validation - checking 3+ premium suppliers
  6. Build analysis tables
  7. Revenue projections
  8. Generate report

Many iterations. Each round I understood something needed fixing - validate data, refine searches, correct calculations. For example: pricing needed to target restaurants directly, not distributors, because the company wants direct sales and needs to understand unit economics at that level.

Throughout the process, I used the /command to save insights to the knowledge base.

Reproducing the Work

Next market research request came. Before starting fresh, retrieved from the knowledge base. The accumulated insights from Atlanta - what worked, what needed adjustment, methodology refinements - all available.

Generated a comparable report. Same depth, same quality.

The Skill Architecture - More Than a Template

Skills can be simple - a few instructions in a markdown file. But they can also be complex systems.

The market research skill includes:

  • Workflows - step-by-step processes for each phase
  • References - API documentation, data sources, methodology
  • Scripts - actual Python code for data collection and processing
  • Cross-references - the research skill points to a separate design skill for report generation

This separation matters. Research logic changes independently from visual design. Update one without breaking the other.

pbf-market-research/
├── SKILL.md                    # Router + principles
├── workflows/
│   ├── full-research.md        # 8-phase workflow
│   ├── collect-restaurants.md
│   ├── add-population.md
│   └── validate-pricing.md
├── references/
│   ├── google-places-api.md
│   ├── data-aggregation.md
│   ├── population-sources.md
│   ├── pricing-sources.md
│   ├── revenue-model.md
│   └── methodology-template.md
└── scripts/
├── sushi_search_template.py
├── aggregate_by_city.py
├── add_population.py
├── calculate_density.py
├── calculate_financials.py
├── compare_pricing.py
└── market_summary.py

How We Got Here

We didn’t design this architecture upfront.

After the first Atlanta research - messy, iterative, lots of corrections - I had Claude Code read the final report and break it into components. Combined with insights saved via /command throughout the process, plus documentation of what worked.

Second research benefited from:

  • Documented methodology from first research
  • Accumulated insights from /command
  • Structured breakdown of the report components

Same depth and quality, but design inconsistency. Asked Claude Code to analyze the Atlanta report’s design and create a design skill. Then redesigned the second report - came out beautiful.

After two successful researches, we stopped to consolidate. Built the full skill architecture based on the validated process - workflows, references, scripts, cross-references to the design skill.

The principle: after a complex process, stop to extract learnings and build reproducible workflows. That’s how methodology becomes a skill.

Process → Skill → Agent

This was the plan from the start: first validate the methodology works, then wrap it in an agent.

The goal: build a Claude Agent SDK agent with this skill embedded.

This is “Build skills, not agents” in practice:

  1. Develop the skill through real work
  2. Validate it reproduces quality
  3. Then build the agent

The agent becomes a delivery mechanism for proven methodology. Not an experiment - a productized capability.

Any market Pure Blue Fish wants to enter: one agent, accumulated knowledge, consistent output.

What I Learned

“Build skills, not agents” - this is what it means in practice.

Skills are reusable, accumulate knowledge, improve with use. The model doesn’t get better. The system around it does.

But it’s more than skills. It’s a way of working with AI:

  • Context management - maintaining continuity across sessions
  • Learning from process - documenting what works, what doesn’t
  • Iteration discipline - each round refines understanding
  • Implementation over theory - reading articles is easy, building until production is where learning becomes real

The continuous learning article gave me a concept. Building the research agent made me understand it. Using it on real work proved it. Creating skills made it scalable.

That’s the loop: learn → build → use → systematize → deploy.