The work moved up a level.
PractiCAI is a place to be practical about development, AI and the cloud. This is the essay the rest of it stands on.
Agents write the code now, and they write it more consistently than we do. They still need us to guide them. So we stopped working at the level of the editor and started working at the level of the decisions.
The person who works that way is the Modern Principal. A Principal leads the software lifecycle from above, not from underneath.
From underneath
Underneath is where most of us learned the work: one ticket, one branch, one file at a time. You learned each tool by living inside it. The repository took years, and so did the board, the wiki and the cloud console. Each one held its own piece of the picture. The whole picture lived in meetings, in one person’s head, or nowhere.
Most of the effort went into carrying the work across those gaps. The idea you started with thinned on every crossing.
From above
From above, the whole lifecycle is in view at once: the requirements, the plan, the build, the tests, the deployment and the review. Agents do the work at each station. A person stands at the gates and decides.
We named our conductor Casey. Casey runs an engagement as a line of stations in one fixed order; each station does its work underneath and keeps the record that proves it done. Casey stops where a person asked it to, and waits. Much like Casey, the Principal works above the line. The calls at the stops are the Principal’s. (The Conductor, in our vocabulary.)
Read · the Conductor, in the vocabulary
You no longer have to master GitHub, Jira, Confluence and every cloud console to use them. The agents work in them. You still have to read them, because that is where the record is written. But StellarView brings them to you: when you need them, where you need them, how you need them, and why.
The languages a Principal speaks
A team’s work is written down in a few places. A Principal reads all of them and speaks in their terms:
- GitHub. The branches, the pull requests and the merge. A phase is finished when its pull request lands.
- Jira. The epics, the stories and the sprint. The board is how a team sees its own work.
- Confluence. The documentation, written as the work happens and kept for the team that will run the product.
- The cloud. The accounts, the services and what they cost to run. A build is real when it boots there from clean.
Speaking them does not mean living in them. It means you can read what an agent did there, and say what happens next in words the team already uses.
Read · Every claim cites a fact
Read · the Action Center, in the vocabulary
The roles a Principal works with
A build has several people around it, and each wants something different from the same work:
- The developer wants it done right, and wants to see how it was done.
- The project manager wants the sprint, the ceremonies and the gates, kept honest.
- The platform visionary wants the idea built, deployed and running.
- The investor wants to know how the work becomes a product.
Read · Every claim cites a fact
Agents sit at the table as well. Each has a seat and a job: one runs the meeting and keeps it on the record; one answers for the account and what it spends. An agent proposes and cites the record when it does. The call goes to a named person.
The Principal speaks to each of them in their own terms: to the developer in branches and tests, to the project manager in the sprint, to the visionary in the running product, to the investor in what it will become. To the agents, the Principal speaks in decisions.
We fold time
From above, you can see the whole run, so you can predict it: the code, and the meetings too. When the prediction holds, the work happens in the wait. The pre-read is on the table before anyone sits down: why we meet, the solutions on the table, and what we want to arrive with. We call that folding time. The Pulse is the rhythm it runs on.
Read · The Control Layer, part 2
What it looks like
We built SprayPath this way, in the open. Its documents went in. One automated motion planned it, built it phase by phase, each phase with its pull request, and filmed it. The meetings were the ones a team already holds: Sprint Planning, refinement, the Sprint Review and the retrospective. People made the calls at the gates.
The record of that sprint is in Cyborg SDLC, starting with one sprint, on the record. The product it built runs, and you can watch it run.
Read · one sprint, on the record
Why now
Time is moving faster than teams can learn the tools. A team that tries to learn the old way first will not keep up.
Nobody brings you all the way there. Few have built a way to do it. We sympathize, because this was our problem too. We built StellarView to solve it for ourselves, and PractiCAI is where we show the work.
The drawings are explainers, and they are labelled as drawings. Every other picture here is a real screen.
Enter the practice
Everything we say here has a film, a record or a running app behind it. Start where you are:
- If you want the daily practice: read The Discipline, what a Principal drills and why the craft of the lifecycle lasts while the tools change.
- If you want to hand the picture to someone else: read The Living Curriculum, the language a Principal uses to teach the work to people and to the agents that build it.
- If you want to see it: watch the films, or follow Cyborg SDLC from the start.
- If you have something to build: bring your documents.
The work has not gone away. It moved up a level, and the Principal moved with it.