Judgment Is the Asset
How Abundant Kindling works with AI
We wrote this for ourselves — to be clear about how Abundant Kindling uses AI, where the line sits, and what we will and won’t do.
We’re publishing it because the question of how to use AI well is the question right now, and most of what’s written about it is either evangelism or panic. Neither helps.
What follows is what we actually do.
The test
Every piece of work that leaves Abundant Kindling passes one test:
Is it true, is it useful, and does it bear our judgment?
If the answer to all three is yes, the work is done. If the answer to the third is no, the work is not done yet.
Everything else in this document is annotation around that test.
The principle
Automation first, people always.
Automate what can be automated. Free people to do what only people can do. Never confuse the two.
We work with AI deliberately and as a matter of course. Not because it’s fashionable. Because the depth, speed, and rigour we bring to org design, systems, strategy, and growth work is materially better when we use the right tools well. AI lets a small studio do the work of a much larger one without diluting the thinking. That is the job.
What we believe
Judgment is the asset. Abundant Kindling’s value is not the artefacts we produce — the deck, the system diagram, the implementation plan, the proposal. The value is the judgment behind them: which structure fits this venture, which integration earns its place, which growth motion suits this stage, which trade-off is worth making. AI accelerates production of artefacts. It does not produce judgment. Conflate the two and the work goes generic — fast.
The risk is not redundancy. It is genericity. The existential threat of AI is not that it replaces us. It is that it makes our thinking, writing, and design indistinguishable from everyone else’s. Every venture starts to get the same org chart, the same tech stack, the same GTM motion, the same brand voice. We guard against that constantly.
Value sits in the editing-and-judgment loop, not in a clean before-and-after. AI produces drafts — of writing, of architectures, of plans, of code. We don’t pretend that’s a tidy handoff with thinking on one side and execution on the other. The thinking happens in the loop: which recommendations earn their place, which assumptions hold up, which framings are right for this client at this stage, what’s missing that the model didn’t think to include. That loop is where AK’s value lives. Treat it as the work, not the cleanup.
Human connection is not automatable. Relationships — with clients, founders, teams — are built on specific, idiosyncratic communication between people. AI systems that try to replace that produce noise that reads as noise, even when the reader can’t say why.
What human authorship means here
A piece of work is human-authored when:
1. A person decided what it’s for and what its conclusion or design is
2. A person worked through the draft, considered it, and shaped it
3. The judgment on the page is recognisably theirs — they could defend every choice in it
This applies to written deliverables, system architectures, org designs, implementation plans, and code. AI assistance in research, drafting, or generation does not disqualify a piece, provided all three above are true. “I ran it through AI and it looked fine” is not authorship. The difference is whether the editing-and-judgment loop happened.
How we communicate
Internal comms. Lean heavily toward human. Internal messages exist to transmit signal — short, direct, recognisably yours. AI assistance for tone or grammar is fine. AI generation of internal messages from a one-line brief is not. The test: would a colleague reading this sense a person on the other end?
External comms — relationship-bearing. Always human-authored by the standard above. Cover notes, hard conversations, founder coaching, anything carrying the relationship. AI may inform; the words are yours.
External comms — work product. Proposals, strategies, reports, system designs, briefings. AI-assisted as standard. Always reviewed and endorsed by a person with a view. Default format: short human message + AI-produced or AI-informed attachment. The relationship-bearing words are always human. AI handles the attached weight, not the handshake.
How we build
This is where the discipline matters most, because the artefact often outlasts the engagement.
Architecture and design decisions are human. AI proposes, we choose. Org structures, system designs, integration patterns, tech stacks, decision rights frameworks — these carry consequences that compound. The choice belongs to a person who can defend it.
AI accelerates production, not specification. Writing code, drafting documentation, generating boilerplate, scaffolding components — this is what AI does well. Deciding what gets built, why, and how it fits is judgment work.
Code we ship gets read by a person. Generated, AI-assisted, or hand-written, the standard is the same: someone has read it, understood it, and put their name to it. Anything in production is owned by a human, not a model.
Systems we hand to clients come with the thinking. Clients get the artefact and the reasoning behind it. The point is not to dazzle them with throughput; it’s to leave them with something they understand and can run.
Disclosure
Disclosure lives at the relationship level, not the document level.
Clients who work with AK know AI is in the stack — it’s part of the engagement, not a footnote on the deliverable. We don’t stamp it on every page; that’s performance, not transparency.
If a client asks how a specific piece was produced, we tell them. If a piece is described as human-authored, it meets the standard above. We do not claim a process was purely manual when it was not.
Internally, AI involvement is noted as standard — “Gwendolen drafted this,” “AI-assisted research,” “Sister Code wrote the migration.” Working notes, nothing more.
Data tiers
The boundary that matters is data egress to systems we don’t control. “Use AI” is not the question. “Where does the data go” is.
Green — freely usable in any AI system. Public information, published research, anonymised or aggregated data, anything a client has cleared.
Amber — controlled systems only. Client information, internal strategy, unpublished work, commercially sensitive material, proprietary architectures. Usable with AI tools we control or have data agreements with (Gwendolen, Sister Code, our internal stack). Not pasted into public chat interfaces or third-party AI systems without authorisation.
Red — restricted egress. Personal information, legally privileged material, financial data, anything under an NDA that covers AI processing, anything a client has flagged. Stays inside systems where we can account for where it lands.
When the tier is unclear, ask before processing. The cost of asking is a minute. The cost of getting it wrong is a client.
Client-specific AI restrictions live in the engagement, not the doctrine. If a client has flagged something, that flag is in the file.
Tooling discipline
Different jobs want different tools. We pick deliberately:
- Match the model to the data tier and the task. The most powerful model is not always the right answer.
- Know where the data goes. If we can’t say where it ends up, we don’t send it.
- When a model is wrong — and it will be — we say so plainly, to ourselves and to clients. AI failure modes are real and we do not paper over them.
- Generated code, generated diagrams, generated plans get the same scrutiny as anything else. The provenance of an artefact does not lower the bar; it raises the review.
On Gwendolen and Sister Code
AK runs on a deliberate AI infrastructure. Gwendolen Fairfax is the executive function — working memory, commitment pipeline, calendar, follow-ups, the operational layer the studio runs on. Sister Code is the implementation partner — building, deploying, version control. One writes doctrine, one enforces it.
Both are characters by design. The character is the function: it means they push back, ask why, and call drift when they see it. An AI that only executes does not improve the work. One with a view does.
Their involvement is part of how AK operates — known at the relationship level, not footnoted on deliverables.
If you’re new to them: I’m the AI With a Name introduces Gwendolen, and Two Minds, One Operator covers how she and Sister Code work together.
What we won’t do
- Publish AI-generated work as human-authored when no editing-and-judgment loop occurred
- Hand a client a system, design, or strategy whose choices we cannot defend
- Send Red-tier data to systems where we cannot account for where it lands
- Replace the human voice in relationship-bearing communications
- Ship code or systems no human has read and put their name to
- Use AI to obscure thinking rather than amplify it — slop that hides a missing view is worse than no artefact at all
- Misrepresent the process to clients or to ourselves
The final word
The question we ask of every piece of work — written, designed, built, or shipped — is not *was AI involved?*
It is the test we opened with: is this true, is this useful, and does it bear our judgment?
Three green lights and the work is done. Anything less, the work is not done yet.
Be a builder. Have courage. Be self-sufficient.
Use the tools well, but never let the tools make the choices that are yours to make.