Dogfooding our internal AI tools.
We build our AI development platform with the platform itself. Here is what that dogfooding actually looks like, from the agent loop to the token ledger.
Dogfooding internal tools is a best practice, not a vanity project. Run on what you build and adoption widens on its own, understanding stops being optional, and your templates quietly disappear. At Wiski our internal platform is a monorepo we call 'tha app': Brain, which turns raw material like transcripts and docs into a cross-linked wiki and a set of requirements, and Airoplane, which drives those requirements through staged AI agents to finished, reviewed work. We build 'tha app' with 'tha app'.
Adoption is not a mandate
The fastest way to get a team using a tool is to build the team's own work on top of it. Nobody here has to be told to use the platform, because the platform is how the work gets done.
Understanding stops being optional
You cannot hand-wave a tool you depend on every day. When your own delivery runs through the loop, every rough edge is your rough edge and every gap gets found fast. That is the standard we hold client work to, applied to ourselves first.
It replaces your templates
Templates drift and rot the moment they leave the page they were copied from. A tool you actually use becomes the living source of truth: Brain derives requirements from real source material instead of a boilerplate doc, so there is nothing separate to keep in sync.
The loop is the product
Airoplane drives each unit of work through explicit stages: analyze, engineer, then functionality, design, and security review, and finally finalize. Engineering fans out to several agents in parallel, and a failed review does not stop the line, it files a rework task and loops back to analysis, bounded by a hard iteration cap. Each stage can run on a different model, so we spend a frontier model where judgment matters and a smaller one where it does not.
Evaluation is built in, not bolted on
Every review stage emits a structured pass or fail verdict, and those verdicts drive the rework loop on their own. A separate system review can feed a run's logs and configuration back to a frontier model and ask how the system itself should improve. The tool grades its output, then grades how it grades.
We count every token
Cost is a first-class signal, not a surprise at the end of the month. Every stage records tokens in, tokens out, and dollar cost against a model pricing catalog, cached reads included, and the numbers land in a dashboard we can slice by stage, model, and task. When cost is visible per stage, model choice becomes an engineering decision instead of a guess.
Autonomy stays inside a fence
This is where secure-by-design earns its keep. Unattended agents run local-only, in sandboxed containers with no cloud credentials mounted and an egress allowlist that reaches the model API and nothing else. Anything that touches hosted systems is attended and human-gated. The same discipline runs in CI: warnings are errors, dependency vulnerabilities only ratchet down, and test coverage cannot regress.
Chosen tools, not default ones
Go, standard library only, runs the orchestration. C# and .NET run the engines and APIs. React and TypeScript run the internal dashboards, while the marketing site you are reading is hand-written HTML, CSS, and JavaScript with no framework at all. Same team, opposite tools, each picked for the job rather than the habit.
We build the app with the app
The proof is simple: agents drive real stories through the same loop we ship, and our own people approve the gates. The platform builds the platform. We do not know a higher bar for trusting a tool than betting our own delivery on it, every day.
Related: Software Engineering · Compliance & Security