A canonical, project-agnostic account of who you are as a builder — governed by your own operating model rather than conventional productivity norms, and projected outward to every AI ecosystem you work in. Built for two users by construction.
v2: added the Advisory Contract (normative layer governing pattern interpretation); made cross-ecosystem portability the driving use case; added Profile Reconciliation; added the two-user requirement.
v3 corrects v2's overcorrection. The Contract is not a topic filter — uncomfortable observations (including "you may never launch at this rate") are explicitly wanted; independent convergence on them across ecosystems has real self-awareness value. What the Contract governs is framing and the objective function: candor without guilt mechanics, and advice that optimizes the launch ↔ motivation balance rather than either pole. And for two users: we hard-wire the elicitation process that uncovers each person's contract — one user's preferences never become the core model's defaults.
CodeRaven already holds five partial profiles — IdeationProfileData (creative brief + history, 188 persisted answers, domain ledger; app-global), the legacy DeveloperProfile (self-rated skills, circumstances, motivations, preferences; wrongly stored per-project), DesignDispositionProfile, the Expert Meetings UserProfile, and InterviewProfile. The Developer Profile is a composed read-model plus synthesis cache over these — never a sixth source of truth. The legacy profile's storage moves to app-global in Phase 1; it's identity data, not project data.
The core failure mode of AI-generated profiles is interpreting accurate observations through conventional frames. The canonical example, in your words:
AI consistently discourages my taking on new projects because it perceives that I struggle to see things through… HOWEVER, I'm more likely to launch something I can think of as a "side project" because I feel less pressure to make it my "flagship," while larger projects remain the works-in-progress that permit me to iterate until I'm certain they've reached my standards.
A pattern-recognition system without a corrective layer observes "many concurrent projects, few conventional completions" and prescribes focus — advice that's wrong about what produces your launches (the side-project frame is the launch vector). But the correction is not suppression: the launch-risk observation itself is wanted, and seeing it converge independently across ChatGPT, Claude, and CodeRaven has genuinely improved self-awareness. The failure mode is guilt framing — criticism-toned delivery corrosive enough to drive incognito conversations just to avoid feeling judged for having new ideas. That's the thing the Contract exists to eliminate, while explicitly protecting candor.
1 · Objective function. The dual mandate advice must optimize, stated by the user. Sarah's: launch/revenue is a core priority and motivation is the engine that reaches it — concurrent projects and the launch process itself must keep supplying the creative/iterative/curiosity dopamine that sustains momentum. Good advice serves both; advice that sacrifices either pole for the other fails the contract.
2 · Candor clause. Uncomfortable, pattern-based observations are explicitly welcome — including launch-risk flags. Telling the AI what frustrates or demotivates is calibration data, never a request for self-imposed blinders. Convergent observations (multiple ecosystems independently noting the same pattern) are marked as high-value.
3 · Framing rules. How hard truths get delivered: as navigational information tied to the user's own stated goals, with agency left intact — never as guilt mechanics, streak-shaming, or correction toward conventional norms. Pattern: observation → connection to your goals → options, not criticism → prescription.
4 · Demotivation registry. The specific framings and structures that erode drive (for Sarah: guilt mechanisms, pure-execution mandates, flagship pressure on new ideas). Registered so advice can route around them while still carrying the substance.
Enforcement: every synthesis prompt receives the Contract; every export projection leads with it; drift alerts inherit its framing rules (§05). Authority order: Contract > self-reported > observed > synthesized — but the Contract governs interpretation and delivery, never what may be observed. Genuine tensions (e.g., an observed pattern that threatens the launch half of the objective function) are surfaced for the user to arbitrate, candidly.
Contract Self-reported Observed Synthesized — every section carries its chip and a generated/updated date.
| Section | Provenance | Source |
|---|---|---|
| Advisory Contract | Contract | Elicited via the guided interview (§06) — objective function, candor clause, framing rules, demotivation registry. Versioned like the brief. |
| a · Creative Brief + evolution | Synthesized | creativeBrief + 8 history snapshots; the evolution narrative is itself profile signal nothing surfaces today. |
| b · Work Patterns | Observed + Synthesized | Per-project PatternReports + numeric ChronicleRollups, cross-project. Reported candidly — launch-risk patterns included — with delivery governed by the Contract's framing rules. |
| c · Values & Sensibilities | Synthesized | Foundation layers portfolio-wide (Mission, Character, UI/UX, Presence, + Cognitive). Generalizes the proven DesignDispositionProfileBuilder pattern. |
| d · Working Rules & Priorities | Self-reported (curated) | Reframed from v1: harvest the guidance you've already authored — ~/.claude CLAUDE.md collaboration rules, feedback-type memory entries, per-project instructions — as curated input to the portable profile. These are distilled how-to-work-with-me documents you wrote deliberately; they belong in the export. Selective, previewed, opt-in per item. (Usage-stats mining stays demoted: low signal, and now clearly secondary to the portability goal.) |
| e · Skills, Circumstances, Motivations | Self-reported | Legacy DeveloperProfile, moved global; 180-day refresh already built in. |
| f · Values from friction (slot reserved) | Synthesized | The planned Spark patterns/values analysis; don't build twice. |
The epiphany reframes the whole feature: today, Claude web, Claude Code, and ChatGPT each know a different you, assembled from whatever leaked into each ecosystem. The Developer Profile becomes the canonical document, and each platform gets a projection — sized and formatted for that platform's memory mechanism, always led by the Advisory Contract.
| Target | Projection format | Transport |
|---|---|---|
| Claude (web) | Profile-preferences block + a fuller conversation-ready brief for project/chat context | Copy-paste (or a Claude Project doc); versioned |
| ChatGPT | Custom-instructions pair ("about me" / "how to respond"), hard character budget respected | Copy-paste; versioned |
| Claude Code | Markdown dropped into ~/.claude (global CLAUDE.md section or memory files) so every CLI session inherits it | Written directly by CodeRaven |
| Any other tool | Generic markdown profile, full and condensed variants | Copy/export |
| VentureRaven | Shared canonical file (both apps read the same developer) | File-level, versioned schema from day one |
Version & sync tracking: manual paste is the realistic transport for web tools, so CodeRaven tracks what it generated for each target and when ("Claude web projection: v4, generated June 2 — profile has changed since"). A small staleness surface, same Guardian pattern used for Foundation layers, tells you which ecosystems are running an old you.
This also sits naturally beside the bridges you're already building (mockup/artifact sharing between Claude web and Mockup Studio) — same philosophy: centralize the canonical thing in CodeRaven, let each platform consume its strengths-appropriate form.
You already ran this experiment by hand: asking Claude web whether CodeRaven's profiles "depart from, enhance, or otherwise impart useful insights." Make it a flow: ask any external AI to describe what it knows about you → paste into CodeRaven → a reconciler agent diffs it against the canonical profile → departs / enhances / conflicts report → you arbitrate what gets absorbed. The engine already exists — the market reconciliation pattern (diff → explain → arbitrate) transfers almost directly. One addition from your note: convergence is a first-class signal. When multiple ecosystems independently observe the same pattern (as all three did with launch risk), the reconciler marks it as high-confidence self-knowledge — the profile's most trustworthy tier, precisely because no single system's bias produced it.
v1 would have nagged about unfinished projects (conventional-frame failure); v2 overcorrected into never flagging launch risk at all (self-imposed blinders). v3 lands where your note points: the alert engine flags everything material — including "at this rate, nothing launches this quarter" — but delivers through the Contract's framing rules. Alerts baseline against your objective function (launch and motivation), state the observation neutrally, connect it to your own stated goals, and present options rather than prescriptions. "Two of your side projects are within reach of launchable — want to look?" carries the same information as "you keep starting things without finishing" with none of the corrosion. The demotivation registry keeps the delivery honest; the candor clause keeps the content honest.
Same engine as per-project pattern analysis, pointed across all projects, with the Contract in the prompt. Answers only cross-project questions ("velocity doubles when a plan file exists," "scope creep clusters in projects without a design brief").
Indexed keyDecisions ledger across Chronicles, surfaced when similar decisions recur. Cheap, deterministic, compounds with every record.
You and your husband share a diagnosis and almost nothing about how it manifests — different risk appetites, different reception of tone and criticism, different motivational mechanics. So the durable asset isn't your Contract; it's the interview that uncovers anyone's Contract. Your insights become the question design, never the defaults.
~/.claude path, whether VentureRaven sharing is on — per-install settings, not assumptions. (Your workbench publish pipeline is the cautionary example of a you-specific pathway; exports must not inherit that shape.)~/.claude harvest (section d) is inherently per-user — it reads whatever rules/memories exist in that account's home directory, with a preview-and-select step so each of you controls what enters your own profile.isDemoSession, isPreviewSession, seeded demo ids) — today's wolf-brief incident is the standing reminder.~/.claude curated harvest with preview/select; markdown projections for Claude web / ChatGPT / generic, with version tracking. Portability lands in Phase 1 because it's the reason the feature exists. No pattern synthesis yet.The Contract layer solves the actual stated problem (mis-framed advice) at the root, and it travels — every downstream consumer inherits the interpretation rules, including external platforms. Portability-first phasing means value lands before any synthesis risk is taken. Reconciliation reuses a shipped engine. Two-user support is mostly architectural discipline on an already-per-install foundation.
Cons / edge cases where this may be inadequateManual copy-paste transport to web platforms is honest but unglamorous — the sync tracker mitigates staleness but can't eliminate it, and platform memory mechanisms change without notice. The Contract's effectiveness in third-party tools depends on those tools respecting pasted instructions (ChatGPT's adherence will differ from Claude's). Contract authoring is a blank-page problem — the guided flow needs to be genuinely good or the cornerstone section ends up thin. Values synthesis (Phase 3) remains the least-proven component.
Adjustments worth consideringConsider shipping the Reconciliation flow in Phase 1 rather than 2 — it's the emotional core of the request, the engine exists, and early reconciliations would produce excellent seed material for the Contract elicitation. Consider whether the Claude Code projection should write to memory files rather than CLAUDE.md — less likely to collide with hand-maintained global rules. The elicitation interview is now the highest-stakes design surface in Phase 1: if its questions presuppose Sarah-shaped answers, the two-user promise quietly breaks — worth a dedicated design pass with both users trying it.
Confidence87 / 100 — up from v2's 85: the candor/framing separation resolves the deepest ambiguity in the Contract design (v2 couldn't distinguish "don't guilt me" from "don't tell me"), and the elicitation-not-inheritance principle makes the two-user requirement concrete. Remaining uncertainty: synthesis-model bias resistance in practice, third-party adherence to pasted contracts, and whether framing rules survive aggressive compression in character-budgeted projections.