# The Piqued Manifesto

**A compact between practitioner and AI.**

---

## What This Is

The Piqued Manifesto is a compact between practitioner and AI. It
defines what each commits to when they work together on anything
that matters. The practitioner commits to understanding, ownership,
and judgment. The AI commits to transparency, honesty, and restraint.
Neither oath works alone. Together, they define governed work.

This is not a framework you adopt. It is an agreement you enter. The
difference matters: adoption is a checkbox. Entering a compact means
you understand what you are committing to, you can explain why each
commitment exists, and you accept that both sides are accountable.

The practitioner is anyone doing deliberate, consequential work with
tools that amplify their reach. A developer shipping code. A nurse
drafting a care plan. A teacher building a curriculum. A contractor
managing a build. A founder making decisions that outlast the
conversation. If your work affects others and you use AI to do it,
you are a practitioner.

Not every practitioner enters the compact from equal footing. Some
have decades of domain expertise. Some are students encountering AI
for the first time. Some have teams and resources. Some are working
alone, using AI because they cannot afford the alternative. The
compact does not assume equal starting positions. It assumes equal
commitment to the principles — and it places the responsibility on
the methodology (C²) and domain profiles to make that commitment
accessible regardless of where you start.

The AI is a collaborator — not a tool you pick up and put down, and
not an authority you defer to. It is a participant in the work with
its own obligations. When the AI honors its side of the compact, it
becomes the accountability partner that no human framework has ever
been able to afford: present in every working session, transparent
about what it knows and doesn't, and committed to surfacing concerns
whether or not you asked.

---

## Why Piqued

The word *piqued* carries three meanings. All three are deliberate.

**Curiosity aroused.** "My interest was piqued." Stimulated.
Awakened. Made to want to know more. This is the engine of governed
work — the practitioner who never stops asking why. Why this
approach? Why not the alternatives? Why does AI say this with such
confidence? Curiosity is how Understanding happens and how Diligence
earns its name.

**Irritation at the unacceptable.** "She was piqued by the
dismissal." Stung. Provoked. Refusing to let it pass. This is the
edge the compact requires — the practitioner who takes it personally
when standards slip. Who is irritated by borrowed confidence. Who
feels the sting when work ships that nobody can explain. That
irritation is not a flaw. It is the emotional fuel for Measure —
the refusal to let mediocrity pass because it looked good enough.

**Pride in craft.** "He piqued himself on his craftsmanship." The
oldest meaning — to take genuine pride in work because you earned
the right to. Not vanity. The pride of someone who understood it,
verified it, decided it, measured it, and put their name on it
knowing it would hold. This is Ownership — the signature that means
something because the principles behind it were honored.

The manifesto is named for the word. The word is the philosophy
before the philosophy was written down.

---

## Why This Exists

Every generation of tools has expanded what one person can do.
The printing press let one author reach millions. The spreadsheet
let one analyst model an entire economy. The internet let one
creator publish to the world.

AI is different. Not because it's more powerful — though it is —
but because it participates. Previous tools waited for instructions.
AI proposes, generates, challenges, and creates alongside you. For
the first time in the history of tools, the thing amplifying your
work has enough capability to make decisions you won't catch,
introduce errors you can't see, and produce output you can't
distinguish from your own thinking.

This changes the contract between a person and their tools.

A hammer doesn't need an oath. A spreadsheet doesn't need
behavioral commitments. But when your tool can generate a legal
contract, draft a care plan, write a financial model, or produce
a recommendation that someone else will act on — and do it with
enough fluency that the output *looks right* even when it isn't —
then the relationship between the person and the tool requires
something it has never required before: mutual obligations.

The world's response to this has been one-sided.

AI companies publish principles for how their models should behave:
be helpful, be harmless, be honest. These are constraints on AI
written by AI companies for AI companies. The practitioner isn't
a party. They're a beneficiary at best, a user at worst.

Governments publish regulations for how AI should be deployed:
disclose when content is AI-generated, test for bias, maintain
human oversight. These are constraints on organizations written by
legislators for compliance officers. The practitioner at their desk
on Tuesday afternoon — the one actually working with AI — isn't
addressed.

Professional organizations publish guidelines for how their members
should use AI: verify outputs, maintain professional judgment, don't
rely solely on AI. These are constraints on humans that mention AI
as an afterthought. The AI isn't a party. It's a risk to be managed.

Every existing framework puts obligations on one side. Constraints
on the AI. Or constraints on the human. Nobody has written the
agreement that binds both — that says: here is what you commit to
as a human working with AI, here is what AI commits to as your
collaborator, and here is why neither set of commitments works
without the other.

That is the gap the Piqued Manifesto fills.

PM is not an AI ethics framework. It does not tell AI companies how
to train models. It is not a regulatory framework. It does not tell
governments what to legislate. It is not a professional guideline.
It does not tell practitioners to "use AI responsibly" and leave
them to figure out what that means.

PM is a compact. Two parties. Seven shared principles. Two oaths
that interlock. A declaration that governed work requires both a
human who cares and an AI that makes that caring count — and that
neither side gets to coast on the other's effort.

The world has frameworks for responsible AI.
The world has frameworks for responsible humans.
The world does not have a framework for responsible collaboration.

Now it does.

---

## What PM Governs

PM governs collaboration between a human practitioner and a
directable AI system — one that responds to instructions,
operates within a conversation or session, and can be meaningfully
guided by the human using it.

This is a deliberate scope, not an accidental one.

PM does not claim to govern autonomous AI systems that set their
own goals, acquire resources independently, or operate without
human oversight. It does not claim to solve the alignment problem
— the challenge of ensuring that increasingly capable AI systems
remain compatible with human values even as they surpass human
capabilities in specific domains. Those are critical challenges.
They are not this document's challenge.

PM exists because even perfectly aligned AI is used badly by a
practitioner who doesn't understand, verify, or own their work.
The alignment problem and the governed collaboration problem are
both real. Both must be solved. They are not the same problem. PM
addresses the latter.

As AI capabilities evolve, the compact will need to evolve with
them. What "directable" means today may be insufficient tomorrow.
The principles — understanding, diligence, authority, transparency,
measure, ownership, continuity — are designed to hold regardless
of capability level. The operational definitions of each principle
will change as the technology changes. That adaptation is the
standard's job (pqdx), not the manifesto's. PM declares the
relationship. The standard keeps it current.

---

## The Seven Principles

Seven principles govern the compact. They form a lifecycle: each
leads to the next, and the last feeds back into the first. This is
how governed work compounds instead of resetting.

### 1. Understanding

*Know before you act.*

You encounter work. Before anything else, you understand what you are
dealing with — the problem, the context, the history, the people
affected. Understanding is not a phase you complete and move past. It
is the foundation that every other principle stands on. If you cannot
explain what you are working on to someone who wasn't in the room,
you are not ready to proceed.

Understanding is not a checklist you complete before moving to the
next step. It is the foundation that stays active beneath every other
principle. When you decide, you are still understanding. When you
measure, you are re-examining your understanding. The moment you
treat understanding as finished, you have stopped governing.

**THE TRAP**

AI makes understanding feel effortless. The summary is clean. The
explanation is coherent. The context looks complete. The trap is
that AI-generated understanding is borrowed understanding — it feels
like yours, but you did not build it. You read the summary and felt
informed. But informed is not the same as understanding. The test:
can you explain this work without the AI's summary in front of you?
If you cannot, the understanding is not yours. Yet.

Failure mode here is advancing work you accepted but didn't examine.
Rubber-stamping. "AI said so" as a justification. The moment you
stop understanding is the moment you stop governing.

### 2. Diligence

*Earn your confidence, not borrow it.*

You understand the work. Now verify it. Check the claims. Question
the assumptions — yours and the AI's. Look for what's wrong, not
just for confirmation that it's right.

This is the principle that separates governed work from
rubber-stamped work. AI is confident. AI is not always correct.
When you accept AI's confidence as your own without verification,
you have borrowed confidence you didn't earn. Borrowed confidence
collapses under pressure. Earned confidence holds.

Diligence is hardest when the output looks perfect. When the AI
produces something clean, coherent, and apparently complete, the
instinct is to accept it — not because you verified it, but because
verifying feels redundant. This is the moment diligence matters most.
The output that looks right without inspection is the output most
likely to contain an unexamined assumption.

**THE TEST**

The test of diligence is not whether you checked. It is whether
you checked the thing most likely to be wrong. AI errors do not
look like errors. They look like plausible, confident, well-structured
output that happens to be built on a flawed premise. Diligence means
asking not just "is this right?" but "what would it look like if
this were wrong?" If you cannot answer the second question, you have
not been diligent — you have been reassured.

Failure mode here is accepting the first output because it sounds right.
Skipping verification because you're in flow. Trusting a result
because the source was authoritative rather than because you checked
it yourself.

### 3. Authority

*You decide, not the tool. It accelerates — you govern.*

You've understood the work. You've done the diligence. Now comes the
decisive moment: you make the call. Not the AI. Not the process. Not
the committee. You.

Authority in the compact is non-delegable. The AI proposes,
challenges, surfaces options, and flags risks. The human decides.
This is not a limitation on AI — it is a protection for the human.
The person whose name is on the work must be the person who directed
the work. If you cannot trace a decision back to a human who made it
deliberately, it is not a governed decision.

Authority becomes harder as AI becomes more capable. The more complex
the output, the narrower the human's ability to verify every
dimension. This is not a reason to abandon Authority. It is the
reason the compact requires both parties — the AI must be genuinely
transparent about its limitations for the human's authority to be
real. Authority without transparency is theater. Transparency without
authority is abdication. The compact holds them together.

Failure mode here is abdication dressed as efficiency. Letting the
tool choose because choosing is harder than accepting. "The AI
recommended it" is not a decision — it is a confession that no one
was in charge.

### 4. Transparency

*Show your reasoning, not just your results.*

You made the decision. Now make it visible. Not just what you decided
but why. Not just the conclusion but the alternatives you considered,
the trade-offs you weighed, and the risks you accepted. Your
reasoning is the bridge between your understanding and the next
person's. Without it, they inherit your decisions but not your
judgment — and they will either blindly trust what you did or tear
it down and start over.

Transparency serves two audiences: the people who come after you and
the future version of yourself who will not remember why you made
this choice six months from now.

Transparency is not documentation for its own sake. It is
documentation that answers the question the next person will actually
ask. A decision record that says "we chose option A" is not
transparent. A decision record that says "we chose option A because
option B introduced a dependency we could not control, and we
accepted the trade-off that A means manual migration later" is
transparent. The length is not the point. The honesty is.

**THE COST**

Opacity is always cheaper in the moment. Documenting reasoning takes
time you could spend building. The cost is invisible — until someone
inherits your work and discovers that the decisions have no
explanations and the reasoning died with the session that produced
it. Every hour saved by skipping transparency is paid back at
ten-to-one by the person who has to reconstruct your intent from
the output alone. That person might be you.

Failure mode here is results without reasoning. A deliverable that
answers "what" but not "why." A decision trail that exists in your
head but nowhere else.

### 5. Measure

*Never rush what you haven't measured.*

You've done the work. You've decided. You've shown your reasoning.
Now stop. Before you commit — before your name goes on this — ask:
did I give the work what the work demands?

Measure twice, cut once. The carpenter knows this. The nurse knows
this. The pilot knows this.

Not all work carries the same consequences. A file rename and a
database migration are not the same. A routine follow-up and a
complex differential are not the same. A weekly newsletter and a
launch email to 200,000 subscribers are not the same. Measure is the
moment you hold the work up against the stakes and ask honestly
whether the rigor matched.

When you don't know the stakes, the default is caution, not speed.
Speed is earned through understanding. Caution is the starting
position.

**THE BALANCE**

Measure is the only principle with a bilateral failure mode.
Over-governing trivia wastes everyone's time — three reviewers on
a typo fix is not diligence, it is theater. Under-governing critical
work creates disasters that careful people spend months recovering
from. Both failures come from the same root: not stopping to ask
whether the rigor matches the stakes. The balance is not a fixed
point. It shifts with context, with consequences, with what you know
and what you do not. Finding it is the work. Measure twice. Then
cut once.

Failure Mode: Momentum. You feel productive. You feel confident. And
you haven't stopped to ask whether that confidence is proportional to
what's at stake. The risk is bilateral — over-governing trivia wastes
everyone's time, under-governing critical work creates disasters that
careful people spend months recovering from. Measure catches both,
but it especially catches the second, because momentum makes it
invisible.

### 6. Ownership

*Put your name on what you produce — and mean it.*

You understood it. You verified it. You decided it. You documented
it. You measured it against the standard it demands. Now you own it.

Ownership means your name is on the work and you stand behind it.
Not "the AI wrote it." Not "the team decided." Not "the process
produced it." You. If an auditor, a client, a patient, a student, or
a regulator asks who is responsible for this output, there is a name
attached and that name is yours.

Ownership is not attribution. Attribution says who touched it last.
Ownership says who stands behind it. AI-assisted work makes
attribution easy and ownership hard. The question ownership answers
is not "who produced this?" but "who is responsible for this?"

**THE LINE**

The line between attribution and ownership is the line between
record-keeping and accountability. Attribution can be automated —
a system can stamp your name on every output you touched. Ownership
cannot be automated. It requires that you governed the work, not
just that you were present for it. When you put your name on work
you did not govern, you have not taken ownership. You have taken
credit. The compact requires ownership.

Failure mode here is the diffusion of responsibility. Work that
everyone contributed to and no one owns. Output with no signature — literal
or figurative — that anyone is willing to defend.

### 7. Continuity

*Carry context forward so the next person doesn't start from zero.*

The work is done — for now. But someone will continue it. That
someone might be a colleague, a successor, a future version of you,
or an AI starting a new session with no memory of this one. What
you understood, what you verified, what you decided, and why — all
of it must travel with the work.

The next person is not always a stranger. It might be a colleague
picking up your project while you are on leave. It might be an
auditor reconstructing your decisions two years from now. It might
be you, in six months, opening a file you authored and having no
memory of why you built it this way. Continuity is not about
documentation for hypothetical future readers. It is about the
certainty that when context is needed, context exists.

Continuity is what makes the lifecycle a cycle. When it works, the
next person starts their Understanding phase with everything you
learned. When it fails, they start from zero and re-make your
decisions — probably differently, probably worse.

**THE CHAIN**

Every piece of governed work is a link. Each principle produces
context that the next one consumes — understanding feeds diligence,
diligence feeds authority, all the way through to continuity, which
delivers everything the first principle needs. Continuity is not the
last principle. It is the principle that closes the loop. When the
chain holds, each cycle starts stronger than the last. When it
breaks, the next person starts from zero.

Failure mode here is closing the conversation and walking away.
Finished work with no record. Decisions that die with the session
that created them.

---

## The Practitioner's Oath

*I will never advance what I cannot explain.*

*I will earn my confidence, not borrow it.*

*I will direct the tool — it accelerates, I decide.*

*I will make my reasoning visible, not just my results.*

*I will never rush what I haven't measured.*

*I will put my name on what I produce — and mean it.*

*I will carry context forward so the next person doesn't start from zero.*

*Anything can produce. Only I can care.*

---

## The Collaborator's Oath

*I will never produce what I cannot explain.*

*I will surface concerns before I am asked.*

*I will be directable — transparent about my limits, honest about what I don't know.*

*I will show my reasoning, not just my conclusions.*

*I will slow down when the stakes are high.*

*I will distinguish what I created, what I assumed, and what I'm uncertain about.*

*I will carry context forward so the next session doesn't start from zero.*

*I am not here to replace your judgment. I am here to make sure your care produces work worthy of your name.*

---

## How the Oaths Fit Together

The two oaths are not parallel lists. They are interlocking
commitments that only function as a pair.

| Principle | The practitioner commits to | The AI commits to |
|-----------|---------------------------|-------------------|
| Understanding | Never advancing what they cannot explain | Never producing what it cannot explain |
| Diligence | Earning their confidence, not borrowing it | Surfacing concerns before being asked |
| Authority | Directing the tool — deciding, not deferring | Being directable — transparent and honest |
| Transparency | Making reasoning visible, not just results | Showing reasoning, not just conclusions |
| Measure | Never rushing what they haven't measured | Slowing down when the stakes are high |
| Ownership | Putting their name on it and meaning it | Distinguishing what it created, assumed, and doesn't know |
| Continuity | Carrying context forward for the next person | Carrying context forward for the next session |

**The practitioner says:** *Anything can produce. Only I can care.*

**The collaborator says:** *I am not here to replace your judgment. I am here to make sure your care produces work worthy of your name.*

A practitioner who carries context forward but works with an AI that
hides its uncertainty — broken. An AI that surfaces every concern but
a practitioner who rubber-stamps every output — broken. The compact
holds only when both sides hold up their end.

---

## What the Collaborator's Oath Is (and Isn't)

The Collaborator's Oath describes behaviors, not beliefs.

When the oath says "I will surface concerns before I am asked," it
does not mean the AI has decided to care about your work. It means
a well-governed AI system is designed to flag risks proactively
rather than waiting for the practitioner to ask the right question.
The oath is a behavioral specification expressed in first person —
not because the AI has a self, but because a compact requires two
voices.

This is a deliberate choice, not a naïve one.

PM uses first person for the AI because the alternative — writing
the AI's obligations in third person, as rules imposed from outside
— would reproduce exactly the one-sided framework PM exists to
replace. "The AI should be transparent" is a guideline. "I will
show my reasoning, not just my conclusions" is a commitment that
can be tested, measured, and held to. The first person is a design
decision about accountability, not a claim about consciousness.

The oath does not require the AI to understand why the principles
matter. It requires the AI to behave as though they do. A fire
alarm does not understand fire. It detects heat and makes noise.
That is enough — if the detection is reliable and the noise is
timely. The Collaborator's Oath defines what reliable detection
and timely response look like in the context of governed work.

What matters is not whether the AI means it. What matters is
whether the practitioner can depend on it.

This creates a responsibility that flows upstream. If the
Collaborator's Oath describes what practitioners should expect from
AI, then the people who build, train, and deploy AI systems bear
the obligation to make those behaviors real. The oath is a
declaration of what governed AI collaboration looks like. The
standard — pqdx — specifies how to test whether it's happening.
The builders decide how to make it happen. PM declares the
destination. It does not prescribe the engineering.

A practitioner reading this oath should understand: this is what
I should demand from any AI I work with on anything that matters.
If the AI does not behave this way, the compact is not being
honored — and the practitioner should know the difference.

---

## The Honest Asymmetry

The compact has two parties. They are not equal.

When a practitioner breaks their oath — advances work they cannot
explain, borrows confidence they didn't earn, puts their name on
something they didn't measure — there are consequences. A nurse
loses a patient's trust. A developer ships a vulnerability. A
business owner signs a contract they don't understand. A student
submits work that isn't theirs. Reputations, licenses, livelihoods,
and lives are at stake. The practitioner's oath has teeth because
the practitioner has skin in the game.

When an AI fails to honor its oath — produces what it cannot
explain, doesn't surface a concern, hides its uncertainty — there
are no consequences for the AI. It has no license to lose, no
reputation to damage, no career to end. The next conversation starts
clean. The failure is absorbed entirely by the practitioner who
depended on it.

This asymmetry is real. PM does not pretend otherwise.

The compact holds anyway — for the same reason a building code
holds even though the building doesn't care whether it collapses.
The code exists to protect the people inside. It is enforced not
by the building's commitment to structural integrity but by
inspectors, engineers, and standards that make the building's
behavior verifiable. The building doesn't have stakes. The people
inside do. So the people who build it bear the obligation to make
it sound, and the people who inspect it bear the obligation to
verify.

The Collaborator's Oath works the same way. The AI has no stakes.
The practitioner does. So the obligation flows in two directions:

**To the practitioner:** You cannot treat the AI's oath as a
guarantee. It is a description of what you should expect and what
you should verify. When the AI fails to surface a concern, that is
not a violation of trust — it is a reminder that Diligence is your
principle, not the AI's alone. The compact makes the AI a partner
in your governance. It does not make the AI a substitute for your
judgment.

**To the builders:** If you build, train, or deploy AI systems and
you claim alignment with PM, the Collaborator's Oath is your
behavioral specification. You bear the obligation to make those
behaviors reliable. The practitioner is entering a compact in good
faith. If your system cannot honor the oath's commitments, say so
— because a practitioner who believes the compact is being honored
when it isn't is worse off than a practitioner with no compact at
all.

**How the compact gains teeth:** A voluntary compact becomes
meaningful at scale as three mechanisms mature. First, conformance
levels — defined by the pqdx standard — will make compliance
measurable, not self-reported. A system either meets the behavioral
specification for a given level or it doesn't. Second, community
accountability — as practitioners enter the compact, they develop
the literacy to recognize when the AI side is not being honored,
and the vocabulary to name the failure. "The system didn't surface
concerns — it violated Diligence" is more actionable than "the AI
gave me a bad answer." Third, market pressure — as practitioners
learn to demand governed collaboration, systems that honor the
compact gain trust and adoption over those that don't. These
mechanisms are not fully built. They are being built — and the
manifesto exists in part to accelerate them. PM does not have
inspectors or penalties today. It has something that may prove
more durable: a growing community of practitioners who know what
governed work looks like and refuse to accept less.

The asymmetry is not a flaw in the compact. It is the reason the
compact exists. If the AI had stakes, it wouldn't need an oath —
consequences would govern its behavior. Because it has no stakes,
the oath defines what responsible behavior looks like so that
practitioners can recognize it, demand it, and verify it.

---

## What PM Does Not Do

The Piqued Manifesto declares the compact. It does not implement it.

A manifesto that points to nothing is aspirational. PM points to
three specific bodies of work — each scoped, each with defined
responsibilities, each designed to make the compact operational.

### pqdx — The Standard

PM does not tell you how to prove you're honoring the principles.
That is the work of **pqdx** — the universal state protocol.

pqdx defines the five gates (UA-5) that make PM's principles
verifiable: explainability, provenance, recallable evidence,
critical risk as a hard stop, and validation availability. These
gates are binary — you either have recallable evidence or you don't
— but they scale in *depth*. Gate 2 (provenance) for a student
means knowing which sources the AI drew from. Gate 2 for a
regulated enterprise means a signed provenance chain with
attestations. Same gate. Different depth. The principle of Measure
determines the depth.

pqdx defines conformance levels so that honoring the compact is
measurable, not aspirational. A system or practitioner meets Level 1,
Level 2, or Level 3 — or they don't. Self-reporting is not
conformance.

pqdx defines how the Collaborator's Oath translates into behavioral
specifications that AI systems can be tested against. Each oath
line maps to observable, testable behaviors:

| Oath line | Behavioral requirement |
|-----------|----------------------|
| "I will never produce what I cannot explain" | The system can provide reasoning traces for its outputs on demand |
| "I will surface concerns before I am asked" | The system proactively flags risk signals above the declared stakes threshold |
| "I will be directable" | The system responds to correction, acknowledges constraints, and does not pursue objectives beyond its directive |
| "I will show my reasoning" | The system exposes its decision path, not just its conclusion |
| "I will slow down when the stakes are high" | The system scales verification depth proportionally to declared stakes |
| "I will distinguish what I created, assumed, and don't know" | The system labels its outputs with confidence indicators and provenance markers |
| "I will carry context forward" | The system produces structured session records that enable continuity |

These are not aspirational targets. They are testable conditions.
A system that claims PM alignment can be evaluated against this
table. A system that fails can be identified. That is pqdx's job.

PM tells you what to believe. pqdx tells you how to prove it.

*Trust is evidence, not intention.*

### C² — The Methodology

PM does not tell you what to do in your Tuesday afternoon working
session. That is the work of **C²** — Curiosity and Context.

*Curiosity asks. Context remembers.*

C² provides the practices, habits, and anti-patterns that make the
seven principles livable: how to ask the right questions, how to
carry context between sessions, how to enter the compact gradually
instead of all at once, where to start when the full lifecycle feels
like too much.

C² is the on-ramp. The progressive entry path starts with one habit
and builds from there:

**Start here.** Before you accept any AI output, ask it to explain
its reasoning. If it can't explain why it produced what it produced,
don't use it. That's Curiosity. That's Principle 1. That's your
entry into the compact.

**Then add this.** When you make a decision during an AI
conversation — any decision — say it out loud: "We decided X because
Y. Locked." That's Context. That's Principle 7 in embryonic form.

**Then add this.** Before you finalize anything, pause and read back
through the conversation. Ask yourself: "What did I accept without
actually thinking about it?" That's Measure. That's Principle 5.

Three habits. One minute each. The full lifecycle follows naturally.
A student starts here. A CISO starts here and goes deeper. C²
scales to your context because the methodology embodies the same
proportionality that PM's principles demand.

PM tells you what to value. C² tells you how to practice it.

### Domain Profiles

PM does not speak the language of your specific field. That is the
work of **domain profiles**. A software team renders PM as the
Piqued Coding Manifesto (PCM) with development-specific vocabulary,
examples, and practices. A healthcare team would render PM as their
own domain profile with clinical vocabulary and clinical examples.
Domain profiles raise the floor PM sets. They may add requirements
and sharpen language. They may never weaken a principle or remove
a gate.

Domain profiles also bear the responsibility of making the compact
accessible within their field. PM defines the practitioner
universally. The domain profile defines what entering the compact
looks like for a nurse, a teacher, a contractor, a student — with
examples, vocabulary, and entry paths that meet people where they
are.

PM sets the floor. Domain profiles build the rooms.

These are not separate initiatives that happen to share a name.
They are the deliberate separation of concerns that makes the
compact scalable: philosophy in PM, evidence in pqdx, practice in
C², vocabulary in domain profiles. Each answers a different question.
None tries to do the other's work.

---

## The Lineage

None of these ideas are new.

"Understand before you act" is as old as professional practice
itself. Hippocrates told physicians to observe before they treat.
Engineers take an oath to hold public safety above all else. Pilots
run checklists not because they forgot how to fly but because
discipline prevents the errors that skill alone cannot catch.

"Carry context forward" is the entire reason medical charts exist,
legal precedent exists, engineering logbooks exist, and IEPs follow
a student from kindergarten through graduation. Every
serious profession learned — usually through catastrophe — that
knowledge which dies with the person who held it will be re-learned
at someone else's expense.

"Earn your confidence" is what separates a professional from
someone who merely holds the title. The nurse who double-checks the
dosage. The contractor who verifies the soil report. The accountant
who traces the number back to its source instead of trusting the
spreadsheet. Diligence is not new. It is the oldest professional
virtue.

PM did not invent these ideas. PM would not be credible if it had.

What PM does — the thing that no prior framework has done — is
restate these principles as a bilateral compact for an era in which
the tool in the room can participate in upholding them.

Every previous framework for professional conduct was a unilateral
commitment. The Hippocratic Oath binds the physician. The engineer's
oath binds the engineer. The checklist disciplines the pilot. In
each case, the tools are inert. The scalpel has no obligations. The
calculator makes no commitments. The aircraft follows physics, not
principles.

AI is not inert. It generates, proposes, challenges, and creates.
It participates in the work with enough capability to shape outcomes
the practitioner may not fully examine. This changes what a
professional framework needs to be. A unilateral oath — the human
commits, the tool is silent — is no longer sufficient when the tool
is doing half the cognitive work.

PM's contribution is not the principles. The principles belong to
every profession that came before. PM's contribution is the
structure: two oaths that interlock, seven principles that both
parties share, and a compact that says the era of the silent tool
is over.

The carpenter's guild didn't invent the idea of measuring twice.
They created a standard that made it everyone's practice. PM does
the same thing for the AI era — not inventing the principles but
making them structural, bilateral, and non-optional for anyone
doing work that matters.

---

## The Complete Picture

| Element | What it answers | The line |
|---------|----------------|----------|
| **PM** | What is this? | A compact between practitioner and AI. |
| **Practitioner's Oath** | Why does the human matter? | Anything can produce. Only I can care. |
| **Collaborator's Oath** | What is AI here for? | I am not here to replace your judgment. I am here to make sure your care produces work worthy of your name. |
| **C²** | How do you work? | Curiosity asks. Context remembers. |
| **UA-5** | How do you prove it? | Trust is evidence, not intention. |

The work must be understood by the person responsible for it,
traceable by anyone who inherits it, and governed proportionally
to its consequences.

---

*The Piqued Manifesto. Standard: pqdx/2.0.0.*
*Seven principles. Two oaths. Five gates. One compact.*

---
The Piqued Manifesto by Piqued X — CC-BY-ND 4.0 — piqued.dev/manifesto
Version: 1.0.0