Sattva

What happens when knowledge bases become codebases

A hand thumbs through a drawer of typewritten index cards in a wooden library card catalog.
Photo by Daniel Forsman on Unsplash

An engineer is ultimately responsible for shipping code. A knowledge worker, as I’ll define them here, is ultimately responsible for shipping knowledge: a grant proposal, a training guide, a board update, a recommendation to a school district. Until recently, those two jobs looked very different.

2025

If a program lead at a nonprofit looked over an engineer’s shoulder in 2025, they probably wouldn’t understand what they were seeing. The engineer would be writing code in an IDE like VS Code. If they were ahead of the curve, an AI assistant like GitHub Copilot would be built into the IDE, suggesting the next line and speeding up routine work. The IDE would be synced to a repository that held the codebase, and the engineer would be using the practices of version control: pulling in others’ contributions, committing their own changes, and submitting and reviewing pull requests.

Engineering, 2025: you work in an editor with AI autocomplete, synced to a repository holding README.md, app/ and tests/.

Now let’s look over the program lead’s shoulder. Say she runs programs at an edtech nonprofit. We’d see a familiar routine: a folder in Google Drive, a search through email, a Slack thread, a spreadsheet, the CRM. She finds what she needs, makes sense of it, and builds something new on top of it. If she’s ahead of the curve, she pastes some of it into ChatGPT and pastes the answer back. Either way, she is the one holding everything together.

Knowledge work, 2025: you sit at the center, with separate two-way arrows to Google Drive, Email, Slack, Spreadsheets, CRM and ChatGPT.

2027

In 2027, the program lead will follow much more of what the engineer is doing. Most engineers no longer write code directly. They work through an agent. Some of those conversations are in the weeds, while others are in plain English: describing the user experience, the outcome they want, the tradeoffs.

Two other things have changed. The engineer’s tools are connected to the agent, so code review, testing and deployment happen inline instead of in separate services the engineer logs into by hand. And the repository has grown. It used to just hold the codebase for the product. Now it also holds skills, context and docs that tell the agent how this team works. A style guide keeps the agent’s design choices consistent. A running log of decisions in the docs folder reminds it why the architecture is the way it is. The repository has become a knowledge base.

Engineering, 2027: you work through an agent (plan, act, check) that reads a repository holding README.md, .skills/, .context/, app/ and docs/, and is connected to GitHub, Supabase, Sentry, Vercel, Playwright and Slack.

The program lead’s environment now looks remarkably similar. She works through an agent connected to the tools she used to visit one at a time: Drive, email, Slack, the CRM, the accounting system, and increasingly the funder’s own reporting requirements. The agent works from a knowledge base organized much like a repository. A README says who the organization is and what its theory of change is. A skills folder holds how the team writes a grant proposal or a board update. A context folder holds metrics, funder priorities and past decisions. A programs folder holds the work itself: the model, the curriculum, the playbook.

Knowledge work, 2027: you work through an agent (plan, act, check) that reads a knowledge base holding README.md, .skills/, .context/, programs/ and docs/, and is connected to Google Drive, Gmail, Salesforce, QuickBooks, Slack and a funder MCP.

Put the two 2027 pictures side by side, and the only real differences are what sits in the folders and which tools are plugged in.

What knowledge work inherits

If knowledge bases and codebases are converging, knowledge work stands to gain from decades of engineering infrastructure. Engineers built version control so they would always know what changed, who changed it and why. They built code review, and now tools like Greptile that check each change against the entire codebase. They built tests, so a change that breaks something gets caught before it ships.

Each of these has a counterpart in knowledge work: a version history for an organization’s theory of change, a review that checks a board deck against everything the organization has said before, a test that flags when a grant report contradicts last quarter’s numbers.

This matters more for nonprofits than for most organizations. A nonprofit’s knowledge is its product, and a large share of its operating cost goes into re-explaining that knowledge to funders, boards and partners. When the knowledge lives in one well-maintained place, the agent can produce a board update or a funder report from what the organization already knows, instead of a person rebuilding it from scratch.

Sattva aims to give nonprofits the kind of working environment engineers now take for granted, organized around their knowledge instead of their code.