Bestwork

Nobody wants to update their CV. Now that your work happens through agents, you shouldn't have to. Bestwork turns your agent sessions into a living portfolio — drafted as you work, published by you.

Comment

Inspiration

For the last seven months, nearly all of my work has happened inside agent harnesses — first Codex, then Codex and Claude Code side by side. Proposals, full-stack apps, client correspondence: all of it agent-mediated, with me in the loop. I believe this is what the future of knowledge work looks like — agentic systems as the primary interface for getting digital work done.

Meanwhile, my partner works the same way, and she's on the job market. Her resume doesn't come close to capturing the breadth of what she actually does — and an HR manager isn't going to dig through a GitHub account, especially for a non-technical role. GitHub captures commits without context. LinkedIn captures narrative without proof.

That gap is Bestwork: the work already happens where an agent can see it, so the record of that work should build itself from the source. The CV of the future shouldn't be something you sit down and write.

What it does

Bestwork turns the projects, decisions, and results inside your agent sessions into a living public portfolio.

You connect your harness with one copy-paste command (npx bestwork-mcp). Then, in any project, you say a natural sentence — "help me add this project to my Bestwork."

Here's the magic: the agent is already inside the work. It has the current conversation, the working tree, the git history, the README — so it doesn't ask you to explain your own project from scratch. It surfaces the strongest highlight angles it can see, then runs a short micro-interview for only the things artifacts can't prove: what was the situation before this existed, what non-obvious decision did you make, is there a number? Context the agent already has does the heavy lifting; your answers supply the reasoning and the stakes, in your words. Codifying your work drops from an evening of writing to a two-minute conversation you were already having.

Drafts land in a private inbox rendered exactly as the public page will look. You edit inline, resolve redaction flags (client names get one-click aliases), and publish. Nothing is ever public without your explicit action.

Two more mechanics I think are genuinely new:

  • Outcome check-ins. Shipped work starts a 14-day clock. In a later session, your agent asks "anything happen with X since it shipped?" — so outcomes get captured near-real-time instead of reconstructed from memory a year later.
  • Provenance tiers instead of gatekeeping. Every claim visibly wears its evidence level — self-reported, artifact-linked, or attested. Honesty is the differentiator; nothing is blocked.

How we built it

MCP-first was the founding constraint: the agent where the work happens had to be the capture surface. The MCP server is a small TypeScript package over a platform API — the interview protocol, taste rules, and schema all live server-side in the capture brief, so the workflow can be tuned without users updating anything. Bestwork is model-agnostic and needs no separate API key; drafting happens in whatever model your harness already runs.

The rest of the stack: Next.js (App Router, server-rendered public pages, next/og share cards), Neon Postgres with tenant RLS, Drizzle, Cloudflare R2 for evidence storage (screenshots, etc.), passwordless email auth. Verified with 415 unit/integration tests plus Playwright flows covering the full fresh-account journey — pairing, capture, review, publish — and a live-database matrix for multi-project isolation.

The whole thing was built with agents during the submission window — Bestwork was built the way it expects our user's work to be built.

Challenges we ran into

The hardest problem was giving users two kinds of control at once without breaking the machine underneath:

  1. Narrative control. Agents are great at summarizing and terrible at sounding like you. The fix was structural: the interview protocol forbids drafting until the user has answered, and drafts are built from those answers. Human in the loop is built as a core tenet of the pipeline shape from day one.
  2. Design control. I didn't want another one-size-fits-all profile like GitHub or LinkedIn. Bestwork ships four editorially distinct templates (Ledger, Frame, Mosaic, Night), each with three curated WCAG-tested palettes — real visual systems, not reskins. The challenge was keeping the content schema identical underneath, so the MCP contract never changes no matter how a profile looks. Switching templates never rewrites content or breaks a URL.

A quieter challenge: designing against the "vanilla user." My own setup is elaborate, so every flow was built and tested against a five-minute-old account, an empty profile, and a stock harness install with nothing else configured.

Accomplishments that we're proud of

  • The command surface is a sentence, not a slash command. This makes it way easier for non-technicals to work with it, and it works from a cold start in an arbitrary repo.
  • The full loop runs end to end: sign up → pair → capture → interview → private draft → inline edit → publish, in about ten minutes.
  • Redaction as a first-class object: client names are flagged and aliased once per project ("a maritime-law firm"), never auto-rewritten.
  • Four template systems that pass an honest bar: a published page looks like a design studio made it.

What we learned

  • The schema is the product. Universality comes from one MCP contract, not per-harness integrations. Getting the capture brief right mattered more than any UI decision.
  • Interview beats summarize, every time. Early auto-summarized drafts read like slop. Drafts built from the user's own sentences read more like a person.
  • Evidence displayed honestly beats verification. Showing what's self-reported vs. artifact-linked builds more trust than pretending to gatekeep.
  • Building agent-first end to end taught me that the best specs protect the build from the builder — the "vanilla user contract" section of my spec did more for quality than any test suite that couldn't factor in the edge cases.

What's next for Bestwork

I plan to talk to customers, build in public, and let usage steer — but the near-term roadmap I'm excited about:

  • Follow & social learning. Public profiles become a new surface for builders to share the story of what they make — more narrative control than a repo, still linkable to one. Follow someone whose work you learn from and get notified when they publish something new. Not a social network — no feeds, likes, or follower counts — a learning layer.
  • Testimonials & attestations. Scoped invites so a client, colleague, or boss can add a verified note to a specific project — the highest provenance tier, with identity confirmed and the owner always in control of publication.
  • More expression. Additional templates, and possibly purpose-built widgets for the portfolio surface — while keeping the content contract stable. We can also bake skills into the MCP contract, so agents already have more guidance on summarization styles and 'AI slop anti-patterns.'
  • Sitemap & technical SEO. I didn't have time to think about the site architecture in depth, so I am going to take time to think about the layout of the user's site vs their editor, inbox, and settings pages. I also need to think about how to make the user's sites more discoverable.

Built With

Share this project:

Updates