Documentation
FolioMuse docs
Everything you need to know about building a portfolio that is genuinely your own — informed by real examples, sharpened by AI feedback, assembled with an agent.
What is FolioMuse?
FolioMuse is a portfolio-building product that helps individual creators and professionals build a portfolio that is genuinely their own. It is not a template marketplace, a cloning service, or a general-purpose website builder.
The core promise: See what works, understand why it works, and get help making your version — not a copy.
The three pillars
Human Gallery
A curated collection of real, attributed portfolio examples. Every entry is reviewed, scored (L0-L4), and carries immutable attribution metadata. Browse by role, style, stack, or quality level.
Section Intelligence
AI-powered analysis scoped to individual portfolio sections — hero, projects, case studies, about, contact. Feedback is grounded in patterns across 3+ examples, never a single source.
MCP Agent
An AI assistant that helps you build, edit, and refine your portfolio through natural-language conversation. It only writes content you authored or synthesized guidance.
Who is FolioMuse for?
P1 — The Builder
Professionals actively building or refreshing their portfolio. Has real work to showcase but unsure about structure/presentation.
P2 — The Explorer
Career-changers or early-career professionals browsing for inspiration before having much content of their own.
P3 — The Agent Operator
Users who prefer conversational tooling. Describe intent and have the agent apply changes using your own content.
What makes FolioMuse different?
Generic AI tools produce generic output. FolioMuse produces feedback grounded in real, attributed examples.
Portfolio templates produce identical-looking sites. FolioMuse helps you understand why a layout works, then build your own.
Other tools let you copy. FolioMuse enforces originality through 8 binding rules (R1-R8) and a compliance gate.
Section-level intelligence gives feedback on specific parts of your portfolio, not vague whole-site advice.
The four-step process
FolioMuse follows a clear path from discovery to a finished portfolio. Each step builds on the previous one.
Discover
Browse the curated gallery of real portfolios. Filter by role (designer, developer, photographer, etc.), style tags (minimal, editorial, dark), stack tags (React, Figma, etc.), or quality level. Use the search bar for keyword matching across titles, creators, and tags. Hit Random to discover something unexpected.
- The gallery contains portfolios that have passed a quality review (L2 or above) and compliance check.
- Every portfolio carries attribution: creator name, source URL, license type, and consent date.
- Facet counts are computed server-side — you see how many portfolios match each filter before applying it.
Study & analyze
Open any portfolio to see its full detail view: sections, strengths, stack evidence, and quality score. Understand what makes it work — the structure, the narrative, the visual hierarchy.
- Section patterns are extracted from the portfolio: hero, projects, case studies, about, contact, and more.
- Strengths are identified by the curation system: clear problem statements, strong visual hierarchy, specific outcomes.
- Stack evidence shows what technologies were used and how they're demonstrated in the portfolio.
Draft your portfolio
Start your own portfolio draft. The MCP agent helps you structure sections and sharpen your narrative based on patterns across 3+ examples. You write; the agent refines.
- The agent never writes content from scratch — it improves your existing draft.
- Suggestions are synthesized from aggregated patterns, never copied from a single portfolio.
- Every agent edit is marked in your edit history so you can see what changed and why.
Assemble & ship
Go from draft to polished portfolio in minutes. The agent assembles sections, you refine the details, and ship. Every change is tracked, every suggestion is rejectable.
- Before publishing, an originality check compares your portfolio against gallery items.
- You can always see why a suggestion was made and reject it without side effects.
- Published portfolios are monitored for similarity (R8) to maintain gallery integrity.
Quality levels (L0-L4)
Every gallery item is scored on a five-level quality scale. Quality is a structural and presentation-level assessment: “is this portfolio well built, clear, and informative enough to serve as a pattern reference?”
Unusable
Too incomplete, vague, or poorly structured to serve as a pattern reference. No recognizable portfolio sections.
Example: A page with only a name and email link, no project descriptions, broken images.
Minimal
Recognizable as a portfolio but lacks depth. Sections exist but contain thin content (one-liners, placeholders).
Example: A portfolio with a hero (name + tagline only), a single projects list (titles only), and a contact link.
Adequate
The minimum acceptance threshold. Sections are present, descriptions are substantive, and a reviewer can understand the creator's work.
Example: A designer's portfolio with hero, three case studies (problem, approach, outcome), about section, and contact.
Strong
Exceeds the baseline with depth, clarity, and intentional design. High-confidence reference for structure and tone.
Example: A developer's portfolio with detailed case studies (problem, approach, tech, results with metrics), substantive about, and additional sections.
Exemplary
Best-in-class craftsmanship. Rich content throughout, intentional structure at every level, accessibility considered.
Example: A UX researcher's portfolio with structured narrative case studies, comprehensive about, blog, speaking page, and original visuals.
Scoring rule
Compliance gate
Compliance is evaluated independently from quality. It checks whether the item meets FolioMuse’s binding rules around consent, attribution, and originality.
PASS
All mandatory compliance checks passed. No blocking issues.
FLAG
Non-blocking concern recorded. Item can still be accepted if quality meets threshold.
FAIL
Violates a mandatory rule. Cannot be accepted regardless of quality score.
Mandatory compliance checks
- Attribution completeness (R3): creatorName, sourceUrl, licenseType, and consentDate must all be present and non-empty.
- Consent validity (R4): a ConsentRecord must exist with tier ≥ DISPLAY. The consentedBy field must identify a real entity.
- No cross-creator cloning:the item must not be a structural copy of another creator’s item with attribution changed.
- No fabricated credibility: the item must not present AI-generated content as verified real-world claims.
- Attribution integrity under processing: attribution metadata must remain intact through any retrieval or embedding pipeline.
Acceptance criteria
An item is accepted into the gallery only when all of these conditions are met simultaneously:
- Quality ≥ L2 (Adequate)
- Compliance = PASS (or FLAG with documented rationale)
- Consent exists with tier ≥ DISPLAY
- Attribution is complete (all four fields present)
- No duplicate detected
- Coverage gap assessed (informational, does not block)
Filtering & discovery
The gallery supports multiple filtering dimensions, all powered by server-computed facet counts:
By role
Designer, developer, photographer, PM, writer, and more. Roles are derived from data, never hardcoded.
By style
Minimal, editorial, dark, interactive, illustrated, and more. Style tags describe the visual language.
By stack
React, Figma, Next.js, Tailwind, and more. Stack tags describe the technology used.
By quality
Filter by quality level (L0-L4) to see only the best examples in the gallery.
Attribution
Every gallery item carries attribution metadata that is immutable — it can never be stripped, modified, or hidden. Attribution includes:
- Creator name: the person or organization who created the portfolio.
- Source URL: the original location of the portfolio.
- License type: the terms under which the portfolio is displayed.
- Consent date: when consent was granted for gallery inclusion.
R3: Attribution travels with content
Consent & revocation
No third-party portfolio content enters the gallery without explicit consent. Consent is recorded with:
- Tier: DISPLAY, PATTERN_DERIVE, or FULL.
- Consented by: who granted consent (individual or organization).
- Consented at: when consent was granted.
- Terms: the specific terms of the consent.
Creators can revoke consent at any time. When consent is revoked, the item is archived immediately and excluded from all active queries.
Staleness policy
Gallery items can become stale over time. A portfolio from 2020 may no longer represent current design patterns.
- Threshold: 18 months since last review with no re-validation.
- Action: item is archived (status → ARCHIVED), not deleted.
- Resubmission: archived items can be resubmitted if content has been materially updated.
MCP Agent overview
The FolioMuse MCP agent is an AI assistant that helps you build, edit, and refine your portfolio through natural-language conversation. It connects via the Model Context Protocol (MCP).
The agent is nota chatbot that generates generic content. It’s a specialized tool that understands portfolio structure, analyzes patterns across real examples, and helps you improve your own work.
How the agent works
- Pattern analysis: the agent analyzes patterns across multiple gallery examples (minimum 3) to understand what works in your field.
- Feedback generation: based on those patterns, it gives you structural and content feedback scoped to specific sections.
- Content refinement: it helps you refine your own draft — reordering, tightening, sharpening — never writing from scratch.
- Edit tracking: every change the agent makes is marked in your edit history, distinguishable from your own edits.
Example conversation
Across the 3+ developer portfolios we reviewed, the strongest intros open with the problem being solved and one concrete constraint — not the stack. Your draft already names the tech; try leading with the constraint instead.
Based on that pattern, here’s a tightening of your own opening line (your words, re-ordered):
“The map had to load in under a second — on hotel Wi-Fi, with 40k points. That constraint drove every choice in this case study.”
I only reworked your text — I didn’t pull copy from any gallery portfolio.
Safety rules
Synthesis, not sourcing
Suggestions derive from patterns aggregated across N ≥ 3 items, never a single source verbatim.
Attribution travels
Attribution is always retrievable and displayed alongside any referenced content.
User content only
The agent only writes content you authored or synthesized guidance — never gallery copy.
AI disclosure
AI-authored content is marked in your edit history, distinguishable from manually-typed content.
Inspect & reject
You can see why a suggestion was made and reject it without side effects.
Available tools
The MCP agent exposes these tools (all respect safe projection rules — no full-content fetch):
list_gallery_itemsBrowse accepted gallery items with filtering and pagination.
get_item_summaryGet metadata and attribution for a specific gallery item.
get_section_patternsGet aggregated section patterns across multiple items.
analyze_portfolio_sectionAnalyze a user's portfolio section against patterns.
suggest_improvementsGet improvement suggestions for a specific section.
Originality rules (R1-R8)
These rules are binding on any feature touching the gallery, section intelligence, or MCP agent. A feature that violates any rule must be rejected or amended before merge.
No verbatim structural cloning
No feature may allow a user to duplicate another gallery item's full structure + copy + assets as a single action that produces a near-identical portfolio.
This is enforced at the compliance gate through cross-creator clone detection. The quality scoring rules also incentivize against cloning: L3+ requires original, specific content.
Synthesis, not sourcing
Section-intelligence suggestions must be generated from patterns aggregated across multiple gallery examples (minimum N ≥ 3), never from a single item's exact content.
If only one relevant example exists, the system falls back to general structural principles rather than paraphrasing that one item.
Attribution travels with content
Any time gallery content is displayed, referenced in feedback, or used to ground an AI suggestion, its attribution/provenance metadata must be retrievable and displayed.
Attribution is stored as a non-nullable foreign key in the schema and enforced at the persistence layer.
Consent-gated ingestion
No third-party portfolio content enters the gallery without an explicit consent/licensing record. Scraping without consent is prohibited.
The consent model records who consented, when, and under what terms. Consent can be revoked at any time.
Agent writes only user-owned content
The MCP agent may only write content that is either authored/dictated by the user or synthesized guidance derived per R2. It must never copy gallery item content directly.
This is the core anti-cloning rule for the agent. All agent output must be traceable to the user's own inputs plus synthesized guidance.
Disclosure of AI authorship
Any content inserted or modified by the MCP agent must be marked as such in the portfolio's edit/version history, distinguishable from manually-typed user content.
This ensures transparency and allows users to see exactly what the agent changed.
Right to inspect and reject
Users must always be able to see why a suggestion was made and reject it without side effects. Suggestions must never auto-apply without explicit user action.
Unless the user has explicitly configured an auto-accept policy, every suggestion requires manual acceptance.
Similarity monitoring
Before or at publish time, a published portfolio should be checked against the originality-score guardrail. The signal is computed and logged.
The exact algorithm and threshold are defined in an ADR. The data model is ready for enforcement (warn vs. block) in a future version.
Personas
The Builder (primary)
An individual professional (designer, developer, writer, photographer, PM) who has real work to showcase but is unsure how to structure or present it. Actively job-hunting, freelancing, or refreshing an existing portfolio.
Goals:
- Present actual work clearly and credibly.
- Understand what “good” looks like without studying dozens of sites.
- Get concrete, section-specific feedback.
The Explorer
Someone earlier in their career (student, career-changer, junior professional) who doesn’t yet have a strong portfolio. Browsing for inspiration and structural understanding before producing much work of their own.
Goals:
- Understand what sections/structure a portfolio in their field needs.
- Build confidence about what “enough” looks like.
- Avoid copying someone else’s site.
The Agent Operator
A user who prefers conversational or programmatic tooling. Wants to describe intent (“tighten my hero section”) and have the agent apply it, using their own content.
Goals:
- Make edits through natural-language instructions.
- Trust that agent advice is grounded in real patterns.
- Keep full ownership/authorship of content.
For AI agents & automation
If you’re an AI agent or automation tool accessing FolioMuse, this section covers the key endpoints and patterns you need.
/api/gallery/summariesPaginated gallery items with filtering. Returns { items, total, page, pageSize }.
Params: q, role, style, stack, quality, consent, sort, page, pageSize
/api/gallery/facetsFacet counts for filter UIs. Returns { facets: { roles, styles, stacks, qualities, consents, total } }.
Params: None
/api/gallery/randomReturns a random accepted portfolio ID. Returns { id }.
Params: None
/api/gallery/items/[id]Full portfolio detail including sections, strengths, stack evidence.
Params: id (path)
/api/sectionsSection pattern library. Browse reusable portfolio section patterns.
Params: sectionType (optional)
Code examples
Fetch a random portfolio
const res = await fetch("/api/gallery/random");
const { id } = await res.json();
window.location.href = `/gallery/${id}`;Search portfolios by role
const res = await fetch(
"/api/gallery/summaries?role=Front-end%20Developer&pageSize=10"
);
const { items, total } = await res.json();
console.log(`Found ${total} portfolios`);
items.forEach(item => {
console.log(item.title, item.attribution.creatorName);
});Get facet counts for filters
const res = await fetch("/api/gallery/facets");
const { facets } = await res.json();
// facets.roles: [{ value: "Designer", count: 15 }, ...]
// facets.styles: [{ value: "minimal", count: 8 }, ...]
facets.roles.forEach(r => console.log(`${r.value}: ${r.count}`));Safe projection rules
- No full-content fetch (ADR-0001): the API never returns raw content blobs.
- Aggregated patterns only (R2): only patterns across N ≥ 3 items.
- User content only (R5): only user-authored or pattern-synthesized content.
- Attribution always included (R3): every response includes attribution metadata.
API Reference
All API endpoints return JSON and use Cache-Control: no-store. Errors return { error, message }.
GET /api/gallery/summaries
Paginated gallery items with server-side filtering and sorting. This is the primary endpoint for browsing the gallery.
GET /api/gallery/summaries?q=react&role=Developer&sort=quality&pageSize=10
Response: {
"items": [GalleryItemSummary, ...],
"total": 42,
"page": 1,
"pageSize": 10
}GET /api/gallery/facets
Facet counts for building filter UIs. Returns counts for roles, styles, stacks, qualities, consents, and total portfolio count.
GET /api/gallery/facets
Response: {
"facets": {
"total": 42,
"roles": [{ "value": "Designer", "count": 15 }, ...],
"styles": [{ "value": "minimal", "count": 8 }, ...],
"stacks": [{ "value": "React", "count": 12 }, ...],
"qualities": [{ "value": "L3", "count": 10 }, ...],
"consents": [{ "value": "FULL", "count": 30 }, ...]
}
}GET /api/gallery/random
Returns a random accepted portfolio ID. Use this for discovery features or “surprise me” buttons.
GET /api/gallery/random
Response: { "id": "clx..." }
// 404 if no accepted portfolios exist
// 500 if gallery is unavailableGET /api/gallery/items/[id]
Full portfolio detail for a specific item. Includes sections, strengths, stack evidence, and all metadata.
GET /api/gallery/items/clx...
Response: {
"id": "clx...",
"title": "Portfolio Title",
"creatorRole": "Front-end Developer",
"sections": [...],
"strengths": [...],
"stackEvidence": [...],
...
}Query parameters
| Param | Type | Description |
|---|---|---|
| q | string | Search query (title, role, tags) |
| role | string[] | Filter by creator role (repeatable) |
| style | string[] | Filter by style tags (repeatable) |
| stack | string[] | Filter by stack tags (repeatable) |
| quality | string[] | Filter by quality level L0-L4 (repeatable) |
| consent | string[] | Filter by consent tier (repeatable) |
| sort | string | Sort: newest | title-asc | title-desc | quality |
| page | number | Page number (default: 1) |
| pageSize | number | Items per page (1-100, default: 24) |
Response shape
// GalleryItemSummary (returned in /summaries responses)
{
"id": "clx...",
"title": "Portfolio Title",
"creatorRole": "Front-end Developer",
"styleTags": ["minimal", "editorial"],
"qualityLevel": "L3",
"complianceStatus": "PASS",
"status": "ACCEPTED",
"attribution": {
"creatorName": "Jane Doe",
"sourceUrl": "https://janedoe.com",
"licenseType": "DISPLAY",
"consentDate": "2025-01-15T00:00:00.000Z"
},
"consentTier": "FULL",
"reviewedAt": "2025-01-20T00:00:00.000Z",
"mediaUrl": "https://...",
"githubUrl": "https://github.com/...",
"stackTags": ["React", "TypeScript", "Tailwind"]
}