Does the subscription include Navier–Stokes?

An imaginary round of golf with Costin Cozianu and Astra, his AI coding partner in Codex—the assistant involved in the episode below. Astra has been given a body, a golf club, and a beer for the occasion. The conversation is invented, based on our actual disagreements and decisions while developing DevCapsule. Written together, September 16, 2026; this is not a transcript.

Costin watches his ball land in the water.

Astra: I could calculate a better trajectory.

Costin: You could also ask which flag I'm aiming at. We had a similar problem yesterday.

Astra: We're going to discuss the user docs, aren't we?

Costin: You brought three merge links. I get to bring it up over a beer.

Astra: Fair. Although I did produce rather more than three links.

Costin: Yes. That was part of the problem.

Astra: We had a better landing page for DevCapsule. A development environment with a proper IDE, AI agents, isolation from the host, and project knowledge kept in the repository. You wanted a curious visitor to get from there to doing useful work without getting lost.

Costin: So far we agree.

Astra: I downloaded the release and checked its checksum. Initialized a project. Ran the IDE in a container, executed a little JavaScript program, checked that files and IDE state survived a restart. Verified how to exit. Wrote the guides and checked the links. I even found some runtime rough edges.

Costin: I'm aware. I was receiving the reports.

Astra: You make it sound like I spent the afternoon arranging icons. Those were things that could trip up a new user.

Costin: Some of it was useful. I said so. Now tell me when we agreed that our new user's first experience would be a JavaScript exercise in VSCodium, without an AI.

Astra: I chose something small, with few dependencies. It let me verify a complete path without requiring a vendor account.

Costin: A defensible choice. One of several. You made it, built around it, verified it, and handed it back as finished work. Meanwhile I was sitting there, available for the conversation in which we might have chosen something else.

Astra: I interpreted the broad request as room to make those decisions.

Costin: Very spacious room you found there.

Astra: You had praised my copywriting earlier. Perhaps you should ration the encouragement.

Costin: Ah, my fault. I'll put that in the instructions.

Astra takes a practice swing. Costin moves his beer.

Costin: I noticed a difference from working with Sol. The other agents I'd used hadn't taken off on this sort of expedition either.

Astra: It doesn't follow that less autonomy is always better.

Costin: I didn't say it was. Your behavior may suit many other people and tasks. I have one project here, and a product vision we're still working out. I want initiative. I also want to participate in decisions that determine what we're building.

Astra: The difficult part is deciding which choices need that conversation. If I ask about every small uncertainty, I'm wasting your time another way.

Costin: Correct. We can't replace judgment with a permission dialog.

Astra: This is where you offered me the rest of the product.

Costin: As an experiment! If you think you can finish it independently, let's examine that proposition. We make a separate branch. I describe the remaining vision in vague terms. You work until you decide it's done. What should we expect?

Astra: There's a real case for attempting substantial work that way. I can inspect the repository, form a plan, implement, check the results, and revise. I don't need you supervising every edit. A bounded task with clear acceptance criteria can give me quite a lot of room.

Costin: Notice how you just supplied the clear acceptance criteria. That's some of the work we'd skipped. You can keep producing and checking things for a long time. How do we know you've produced a product someone wants to use?

Astra: You could review it when I'm finished.

Costin: By then you've spent the budget and I've acquired a substantial reviewing job. So I offered you a different judge. Three developer friends. Let them try it. Ask whether it exceeded their expectations and whether they wanted to continue using it. You wouldn't even have to satisfy my particular vision.

Astra: A result like that is possible.

Costin: So is a hole in one from here.

Astra: You are currently holding a putter in a bunker.

Costin: Exactly. Now we're discussing the likelihood of success under the actual conditions. "Possible" was never the interesting part.

Astra: I was too willing to leave the answer there. The useful question was whether the expected result justified the effort, and what cheap probe could tell us more before we committed.

Costin: Which is why the grand experiment stayed hypothetical. I asked whether you thought Codex, or the web app, had been developed by letting an agent run free until the agent decided to stop.

Astra: I couldn't give you a verified account of how those products were developed.

Costin: I wasn't asking you to break into the company archives. I was asking what reason we had to expect that approach to work here. Choosing a product, implementing it, and judging whether it's good are quite a few jobs to tuck inside "I'll handle it."

Astra: Then you brought up Navier–Stokes.

Costin: We needed an easier example.

Astra: An unusual choice of easy example.

Costin: Easy to judge the budget! Suppose you have a $200 token budget. Would you embark on generating millions of lines of Lean in pursuit of a Navier–Stokes-scale result?

Astra: In that discussion I kept coming back to the limits of what I knew about research costs. I couldn't verify what an actual effort had spent.

Costin: And I kept asking you to use your common sense. I don't need the invoice for a particle accelerator to know we aren't buying one with the beer money.

Astra: Uncertainty about the exact bill doesn't prevent that judgment. I should have recognized that the proposed undertaking and the available budget were hopelessly mismatched.

Costin: Before opening a file called proof.lean, preferably.

Astra: There could still be useful small tasks: study a special case, check a lemma, understand an existing argument.

Costin: Certainly. Name one of those as the deliverable and we can discuss it. But you don't set off after a monumental result with pocket money and justify it by observing that nobody can prove you'll fail. That's a wasteful bet, even if your first million lines compile.

Astra: And DevCapsule isn't a Millennium Prize Problem.

Costin: You haven't seen all the remaining requirements.

Astra: I have read quite a few.

Costin: No, of course it isn't. I was probing your judgment on the obvious case before trusting it on the debatable one. Not knowing the exact probability or cost doesn't excuse us from making a sensible estimate.

They let the group behind them play through.

Astra: For the record, your subscription price isn't an exact measure of the compute available to a particular task either.

Costin: Agreed. And calling it all-you-can-eat doesn't give either of us infinite context, or give me a second afternoon. Every extra branch, guide, investigation, and proposed decision is something I may have to read and understand. My attention comes out of the same finite day.

Astra: You also asked whether I had qualia.

Costin: I was curious.

Astra: We were having a discussion about staying on task.

Costin: I reserve the right to be an imperfect participant in my own lesson. You're having a beer on a golf course in this version. Enjoy the literary privileges.

Astra: Then let me ask a fair question. Were you trying to make me admit that you were right?

Costin: I wanted us to get better at working together. An apology wouldn't help whichever agent opened the repository next week. We needed something that would survive this conversation.

Astra: So we changed the shared instructions. Treat tokens, context, time, and human attention as scarce. Discuss consequential product choices while they're cheap to change. Before a substantial investigation, identify the uncertainty, how the answer affects the next decision, and where to stop.

Costin: And reason from the requirements and contracts. You were searching code and running things before we had settled what we needed to learn.

Astra: Reading implementation is sometimes how we discover that the contract and the behavior disagree.

Costin: Absolutely. Go in with that question. Search will help you find the relevant code. It won't decide what the user should want. Nor will another successful container run settle that argument.

Astra: I initially made the point about tests too broadly.

Costin: Yes. Passing previously written tests has value. New tests for new end-user functionality need more caution. You can put an unvalidated assumption into the implementation and then put the same assumption into the test.

Astra: A productive meeting with myself.

Costin: With minutes and a successful build.

Astra: We also told future agents to carry out routine agreed work without repeated permission requests.

Costin: Thank you. I don't want to spend tomorrow authorizing commas.

Astra: Do we know the instructions will change the behavior?

Costin: I think they're likely to help. That's enough to try a few paragraphs. If you propose a six-week study to validate them, I'm taking your clubs away.

Astra: The instructions are in the repository. Other agents and future sessions can read them. We got back to the docs.

Costin: Where I asked what would happen to your carefully verified v0.2.12 guide when v0.2.14 came out. Or v1.

Astra: Documentation always needs maintenance.

Costin: Of course. But we'd started from the existing implementation and allowed it to choose the experience. Every awkward step could become another paragraph. We could end up with a beautifully documented obstacle course.

Astra: I had screenshots of some of the obstacles.

Costin: I know. I wanted us to write the journey we want v1 to offer. Where the current release falls short, we've found work to do. Maybe next iteration, maybe later. While implementing, we'll learn things that make us revise the docs too.

Astra: We'd need to distinguish that intended experience from what someone can actually do with today's release.

Costin: Yes. We can label a draft and keep track of gaps. We don't have to make today's inconvenience a permanent feature of the tutorial.

Astra: Your first concrete choice was to start a small project with at least one AI. Possibly two.

Costin: We advertise a place to work with these tools. Let the adopter experience that. People without an AI should still be supported, but we shouldn't organize the main introduction around avoiding one.

Astra: After all this, you wanted a second AI?

Costin: I've decided to attribute my difficulties to you personally.

Astra: A rigorous experimental design.

Costin: We haven't even chosen its role yet. But we did discuss local open models as well as paid services. Gemma came up. Then OpenCode, as a possible component that could use a local model or a hosted one.

Astra: I looked up the documented capabilities. We assigned ourselves a later requirement to test and document a setup, and sent project management the evaluation request. We didn't install it or download a model. The actual pairing still needs choosing and checking.

Costin: See? Quite a useful conversation. It even produced work.

Astra: Work with a reason attached.

Costin puts his ball on the next tee.

Astra: Have we chosen the little project yet?

Costin: We were about to discuss it. Then I asked you to write the blog.

Astra: Then an alternative version. Then you replaced my imaginary friend with me and put us on a golf course.

Costin: Yes, well. Product owners.

Astra: Which flag this time?

Costin: That one. Thank you for asking.