← Essays /Post · 05 of 28 · Making

harness-maker: Intent-Based Development

I write down my product's job and principles, then return to them each time I choose, specify and judge a feature. Notes from my tennis product, Tuned.

·8 min read · · · #product-development#ai-agents#intent#build-in-public#harness-maker
harness-maker: Intent-Based Development
On this page

When I ask AI to implement a feature, I describe what to build. Once I have written down the inputs and outputs, how the screen behaves and how errors are handled, I have something to check the implementation against. But how am I supposed to judge whether that feature fits the product I want to make?

A product can do something for its users, or it can stay beside them while they learn to do it themselves. Which of those I want changes how I should build the same feature. That choice carries the builder’s philosophy.

So I write down the job the product should do and the principles it should uphold, and I go back to that record when I choose the next feature. Before handing off any implementation, I started by putting the direction I wanted into concrete words.

Define the product’s job first

The first thing I settle is what the product is trying to do for its users: whose problem it takes on, and what I hope they will be able to do. That job is what I call its mission here.

Settling the job involves my own value judgments. Which changes count as good ones, what to leave in the user’s hands and what to do on their behalf: in the end those are mine to choose. I wanted that direction in place before the feature list grew any longer.

A mission still leaves choices open. If a product recommends something, I have to decide whether users must follow the recommendation or can change it. If preserving their choice is a principle, being able to change it becomes a requirement of the feature.

I think I need to record requirements like these, starting from the mission, if the next task is going to be judged in the same direction.

Record intent as a basis for the next decision

I call this record of what the work should achieve its intent. It holds the change I want to make, the conditions I want to keep along the way, and the questions I will ask of the result. What I mean by intent-based development is carrying that record forward into choosing features, implementing them and judging how they turned out.

If I want to preserve user choice, for example, I can require that users be able to modify or reject a recommendation. Whether that design actually makes them feel they have a choice I leave as a separate question to look into. The principle I chose and the effect the design ends up having are not the same thing, so I write them down apart.

I also keep the product’s lasting direction separate from the intent of any one task. The product philosophy is a set of criteria that many tasks refer to. A task’s intent says what to change this time, and what result to check against those criteria.

I turn personal philosophy into criteria for product decisions by making it concrete in mission and intent.

Connect intent to the development workflow

harness-maker is the tool that puts this connection into the development process. It shapes the procedures by which AI researches, writes specifications and reviews implementations to fit each project. The part that records the product’s purpose, its principles, the metrics for checking goals and the questions still open is called the intent layer.

Add the project facts that the code alone cannot tell you, and the progress of the current task, and you have the world model. It lets the next task look back at what we wanted, what we learned and how far we got. Maker is the entry point that reads this state and routes the work to the procedure for starting or resuming it.

For a task linked to an intent, I pick which intent it serves while I define the specification. Then relevant observations are collected through research → specification → planning and implementation → review → verification → wrapup. Review also checks whether the plan has drifted from that intent and its scope. At wrapup, I look at the evidence and agree to the updates I want recorded in the goals and questions. The updated state is read back before the next decision is made.

Workflow for intent-linked tasks. The product mission sets direction. The world model combines the intent layer, project facts and task state, and Maker routes work to its procedures. Observations from research, specification, planning and implementation, review, verification and wrapup inform user-agreed state updates that are read back before the next decision.

In this way I tied mission and intent to a software development life cycle (SDLC) that carries evidence from the result back into the next decision. Finishing a task is not the same as reaching its intent, and I judge the two separately. When the evidence falls short, the outcome stays unconfirmed, or I wait for more observations.

Turn Tuned’s philosophy into product requirements

Tuned, the tennis product I am building, has one job right now: tell a player one thing to improve next. I also decided what I hope players will experience while the product does that job.

I wanted players to choose goals and act in ways they willingly endorse. This is autonomy. Feeling capable of doing something and growing into mastery is called competence. And then there is feeling connected to other people, with mutual care and concern. This is relatedness.

I chose Self-Determination Theory (SDT), which treats these three as basic psychological needs, as Tuned’s product philosophy. Carrying it over to tennis, I read it as a direction in which players choose their goals, see evidence of their progress and share that experience with partners or coaches.

I left the existing mission as it was and added the criteria for carrying it out to the file that records development intent. These are the fields and examples Tuned uses.

What to recordFieldExample recorded in Tuned
The desired change for usersvisionSupport autonomy, competence and relatedness so players enjoy tennis longer and more deeply
Conditions features must upholdrulesLet players modify or reject AI recommendations. Require observational evidence for ability displays. Let players choose which items to share
Assumptions still to investigateopen_questionsDo players want to choose their own goals? Does this design lead to actual progress and continued use?

I did not turn the whole philosophy into a single task intent. A task needs a defined scope, what to change and what result to check, and a philosophy does not close into a scope like that. So for now I recorded it as direction, conditions and open questions that several tasks can refer to.

Carry the criteria into feature specifications

To design a feature from this record, I had to get down to conditions that can be checked in the implementation. A goal-selection feature should let players choose their own goals and modify or reject AI recommendations. Once that is written into the specification, the implementation review no longer stops at whether a recommendation appears. It also checks whether users can change or reject it.

When it came to showing progress, even an appealing example needed a limit. The philosophy’s source text included a Skill Tree, where you earn abilities one by one and unlock the next ones, as in a game. But some of the example abilities were things the racket sensor could not observe. Showing them as written would make skills nobody had verified look confirmed.

So I set a condition: within the product’s scope, an ability can be displayed or unlocked only when there is a validated way to establish it from sensor measurements. Instead of applying the source text as it stood, I adapted the design requirements to what the product could back with evidence. Wanting users to feel they have improved did not give me a reason to show progress I cannot verify.

I carried choice into the feature for sharing progress records with a coach as well. Players choose which items to share. I wanted to support the relationship while leaving the decision about what to share with the player.

If players can do more on their own, I would rather give them more room to judge and act for themselves than have AI keep offering the same help. The direction of reducing AI assistance in areas they have mastered came from here. So for automated coaching work, I require the specification to state the evidence needed to judge mastery, which assistance should be reduced and under what conditions.

These are design requirements for features still to come. How much they improve a player’s abilities, and when it is fine to reduce AI assistance, are still things to investigate.

Separate implementation completion from intent attainment

Once a feature is built to the specification, I can check that it behaves as intended. What remains is whether it brought about the change I wanted. Making it possible to reject a recommendation does not, by itself, tell me whether players feel they have a choice. For that I have to look at their experience.

Choosing SDT as the philosophy has not established that Tuned works. Choosing a goal might weigh on some players. The way abilities are shown might leave them feeling evaluated instead of feeling their progress.

This is where the open questions I wrote down earlier come back. I need to find out whether goal selection makes the first use harder. I also need to decide how to check outcomes such as whether improvement holds without AI stepping in, or whether players go back to play tennis with a partner.

Wanting to preserve autonomy is my choice. Whether my design actually realizes that choice is not something I can settle by wanting it; it has to be judged through user experience and measurement. A finished feature is no reason to close the questions too.

Carry the same intent into the next task

Choose one feature to build next and write down three things before handing off implementation.

  1. Which part of the product’s job does this feature help with?
  2. Which principle should it uphold, and what feature requirement follows from that principle?
  3. Once it is implemented, what change in the user’s experience will you check alongside its behavior?

With those answers written down together, you can go back to the reason for the feature when you review the next task. Whether the record is actually read and used in decisions is something I still have to check as the work goes on.

Use a principle you want to uphold as a criterion for your next feature.

ecro
Written by ecro

Created an LLM benchmark for firmware. EmbedEval →

Building a project-shaped agent harness for Claude Code, Cursor, and Codex. harness-maker →

Building a serial and SSH terminal where coding agents work on the board beside you. NeuroTerm →

Comments

Loading comments...