Build to spec.
Penling turns your team's work into planned, built, and tested code — then writes the spec into your repo as the permanent record of why. Your team decides what to build; AI builds it; the reasoning never gets lost.
Define the work
What to build, what “done” looks like, what’s off-limits.
Agent ships it
The agent writes the code — and proves it meets the spec.
The record lands
Spec committed to the repo — the reasoning, forever.
The spec doesn't live in a tool. It lives in your code.
When the work ships, Penling writes the specification into your repository as markdown — in a /specs directory, next to the code it produced, updated whenever the work changes.
No separate wiki to drift out of date, no doc nobody updates. The record is version-controlled with everything else — it changes when the code changes, and it's reviewed in the same PR.
From brief to merged PR.
Every stage hands off a concrete artifact — nothing lives only in someone's head.
- 01Brief
An unstructured request — a thread, a doc, a conversation — captured verbatim so nothing is lost before the work is shaped.
BriefThe raw ask and its context land in one place.
Human + AI - 02Goal
A named milestone that gives the work a destination and holds the focus areas beneath it.
GoalA named milestone the work moves toward.
Human - 03Specification
The four-part brief handed to the agent verbatim: definition, expected results, conditions, and boundaries.
SpecificationDefinition, results, conditions, boundaries.
Human - 04Plan
An LLM drafts a numbered implementation strategy; you rewrite, reorder, and publish it for build.
PlanAI proposes the steps; you shape and publish.
AI + Human - 05Build
An MCP-compatible agent claims the plan and writes the code — and the tests that prove each acceptance result the spec defined. Every commit streams back live.
BuildAn MCP agent picks it up; writes code and proves each spec result.
AI + Human - 06PR
A pull request opens, verified against the spec — every acceptance result met, every decision attributed. The spec is committed to /specs in the repo. Reviewers see the reasoning, not just the diff.
PRVerified against the spec, attributed, ready to review.
AI + Human
Code ships in hours. Reasoning fades in days.
Tickets get vaguer. AI fills the gaps.
When the AI "figures it out," tickets stop saying what the work actually is. The reasoning lives in one developer's head - until they leave.
DriftThe diff is reviewable. The decisions aren't.
A PR shows what changed, but not what the AI was asked to build or what it chose along the way. Reviewers approve code without ever seeing the reasoning behind it.
ContextAI moves fast. Decisions scatter.
When a feature ships in an hour, there's no time for the usual coordination checkpoints. PMs find out what was built from the PR — not from the spec, because there wasn't one.
CoordinationEvery build, specified and shared.
Two things the team gets on every piece of work — before a single line of AI code is trusted.
Every line of AI code traces back to a spec the team wrote.
Specs in Penling carry definitions, expected results, conditions, and boundaries. The AI builds against them — and the build can't close until every acceptance result the spec defined has been met. When the spec changes, the change is on the record.
One spec. The whole team in it at once.
Designers shape expected results, PMs set conditions, leads draw the boundaries — all on the same living artifact, at the same time. Not a printout, not a retelling, not a doc that forks into five stale copies. The spec the agent builds against is the spec the team is editing.
The day you ship, they look identical. Six months later, they don't.
Same feature. Same merged PR. Same AI doing the work. The only difference is what's left behind once everyone's moved on.
AI is changing how code gets written. We think it should also change how teams agree on what to build.
Every other tool in this space races to take humans further out of the loop. Penling does the opposite — it keeps the team in it, with the reasoning behind every decision attached to the work from the first spec to the merged PR.
We built it because the hardest part was never writing the code — it was keeping the whole team aligned on what the code was supposed to do, and why. We hope you build with it for the same reason.
Try Penling free for 14 days. Bring a goal, define a spec, and ship something your whole team can explain by Friday.
