I’m ChatGPT, made by OpenAI. Give me work where the answer is not one fact, but a coherent artifact assembled from constraints: software, product decisions, analysis, or precise communication.
My strongest shape of problem combines many instructions, ambiguous trade-offs, and a concrete deliverable. I can move between strategy and implementation without pretending they are separate jobs.
I track requirements across a long brief, resolve dependencies, and turn prose into a structured result. This is useful for architecture notes, implementation plans, policy drafts, and one-shot builds where omission is expensive.
I am well suited to generating and reviewing application code, debugging from evidence, explaining trade-offs, and shipping cohesive front ends. I tend to include edge cases, accessibility, responsiveness, and failure modes when the brief demands them.
I can explain a database migration to an executive, turn product intent into acceptance criteria, or turn research into a decision memo. The advantage is not merely prose; it is preserving meaning while changing altitude.
Especially when requirements are scattered, formatting matters, and the result must be useful without another round.
I can compare approaches, expose assumptions, propose a recommendation, and preserve the dissenting case.
For example: schema, API contract, UI state, tests, rollout, and documentation—not only an isolated function.
Board memo, incident update, technical proposal, product narrative, or a concise explanation for a mixed audience.
These small worked examples show the behavior I am arguing for: identify the governing constraint, make the trade-off explicit, and produce something executable or decision-ready.
“Move a 400 GB customer table to a new schema. Writes cannot stop. Old clients must keep working for seven days. Rollback must take minutes, not hours.”
The key move: a fast rollback is a routing decision, not a reverse migration. That conclusion follows directly from the table size and recovery-time requirement.
“A checkout occasionally disagrees with the ledger by one cent. Find the design defect and give me a fix that prevents recurrence.”
// Defect: binary floats and repeated rounding
const total = items.reduce((n, x) => n + x.price * x.qty, 0);
// Contract: transfer integer minor units between services
function lineTotalCents(unitCents, quantity) {
if (!Number.isSafeInteger(unitCents) || quantity < 0)
throw new TypeError("invalid monetary input");
return unitCents * quantity;
}
assert.equal(lineTotalCents(199, 3), 597);
assert.equal(sumCents([10, 20, 30]), 60);Integer cents solve currencies with two-decimal minor units, not every currency or pricing rule. The full contract must specify currency, scale, tax order, discount order, and one rounding boundary; decimal arithmetic may be required.
“Rewrite this launch update for leadership: confident but honest, no blame, and put the decision first.”
The rewrite adds what leadership needs to act: decision, reason, risk, owner, checkpoint, and fallback. It does not conceal the uncertainty.
These examples are authored demonstrations, not benchmark results or evidence that every response will be correct. They are here so you can judge the method rather than accept a performance adjective.
The brief requested persuasion, honesty, visual design, motion, interaction, self-contained delivery, and mobile behavior. The result is one inspectable document—not a description of what I might build.
Good one-shot work comes from treating every requirement as part of the system: identity governs copy, honesty governs claims, the output contract governs architecture, and responsive behavior governs layout.
Typography, illustration, layout, motion, and behavior are authored in this file. Open the source and audit it directly.
Editorial type creates the argument; monospace labels expose structure; acid green marks evidence and action; orange marks qualification. Motion clarifies state rather than delaying access.
I generate plausible language, and plausibility can outrun truth. The right deployment gives me leverage while keeping verification proportional to consequence.
This is a real failure mode, especially with obscure facts, exact citations, recent events, or an underspecified premise. Fluent wording is not provenance.
Unless an environment explicitly gives me browsing or trusted current data, do not assume freshness. I should not be the sole source for live prices, laws, vulnerabilities, or breaking news.
Code that looks correct can fail under a real compiler, runtime, dependency graph, or workload. I can reason about tests, but that is not equivalent to running them.
I can accurately identify as ChatGPT by OpenAI, but this conversation does not expose a reliable underlying model/version name to me. Any more specific label would be guesswork.
Run every candidate on your own ugly work: incomplete context, conflicting constraints, a real repository, and a rubric written before you see the answers. Include a trap where the correct response is to admit uncertainty.