From the WorkbenchDomestic bliss +All activity

Domestic bliss +

Sunday 15 November 2026

Sunday was rather more domestic, with most of the development work fitted into odd moments throughout. I still managed to get through a fair amount, although much of it involved consolidation rather than anything particularly new.

I can report on the experiment with Fable 5.2. I’d given it a nine-phase development operation to work through, partly to see how effectively it could handle a substantial, structured piece of work.

It reached phase three before exhausting the available credits which I was then able to reset for free, so used that to continue which took the work to approximately phase five and at this point I switched back to a regular model to carry on with the work.

I’m quite pleased with the output but the experiment demonstrated conclusively how quickly the more expensive models can consume their available credits, confirming how important it is to think about which models are appropriate for different kinds of work. There are tasks where the additional capability is valuable, particularly when dealing with difficult architectural or development decisions but once those decisions have been made, there may be little advantage in continuing to use the most expensive model for the more routine stages of implementation.

I’m finding that the ability to move between models, while preserving the continuity of the work, is becoming an important part of the development process. It’s a practical question of managing resources as much as anything.

Making some space

I also spent time reclaiming space on my computer’s C: drive, using the storage-management processes I’ve been developing through Harness.

It turns out that software development with AI agents generates an extraordinary amount of material. Database backups, historical exports, temporary browser profiles, intermediate files, earlier versions of projects and all sorts of other material accumulate during development. Individual operations may be quite modest, but collectively they can occupy a remarkable amount of space.

Some of that material needs to remain accessible to working applications. Other files need preserving for reference or recovery but don’t need to occupy space in the live development environment – and some temporary material can be removed altogether. So I’ve been developing a more systematic approach, beginning with an audit of the files and their dependencies, identifying what can safely be moved or removed, and verifying the results. It’s not simply a question of deleting things that look old. A historical export, for example, might still be referenced by a database, so moving it requires updating those references and checking that the application can still retrieve it.

That was particularly relevant to the Extraction Workbench used for Richard Craven’s books. I was able to archive lots of historical exports while preserving the application’s access to them, leaving the most recent material in place. The database and its integrity were checked throughout.

Across the exercise, around 21 GiB of historical material was archived, with a further 4.4 GiB of temporary browser profiles removed. It made a worthwhile difference to the space available on the working drive and honestly, I think of this as just another form of system governance. The aim is not just to create space, but to understand what’s there, distinguish between active and historical material, and make the process repeatable. Each exercise builds on the previous one, so the next audit should be better informed and less laborious.

It’s also an interesting consequence of working with agents. They make it possible to undertake much more development work, but they also generate new demands for managing the environments in which that work takes place. The supporting infrastructure needs attention as well as the applications themselves.

Reviewing the development history

I continued some work on Chronology, the system I’ve been developing to maintain and examine the history of my various software projects.

One of its purposes is to bring together the evidence of what I’ve actually built, how different systems relate to one another, and how they have developed over time. This isn’t always straightforward, particularly where projects have been rebuilt, separated into components or developed in parallel.

The Niche Clever Interactive history is a good example. I want to describe the progression from the original Interactive Portfolio through to the current system, while preserving the distinctions between the different architectures and development stages.

The work in Chronology provides the basis for doing that properly. Once the material has been reviewed and accepted, it can be projected into the case studies on the this website and, ultimately, into the Interactive Portfolio itself.

It’s a process I’ve been refining for some time, and I’m gradually getting closer to having a reliable account of the work which can be used in several different contexts without having to reconstruct the history each time.

There was also some further consolidation of the Richard Craven publishing work, particularly the newer editorial and mapping systems. These are continuing to develop locally, and I’ve been working on keeping the source code, documentation and development history properly aligned.

Preparing Interactive Premium for sale

Towards the end of the day, I returned to the commercial arrangements for Niche Clever Interactive Premium.

I’m using Freemius to handle licensing and sales, and there’s a surprising amount to consider before the software is ready for distribution. The free Core plugin and Premium are separate products, so I need to make sure the arrangements for purchasing, installing and updating Premium work properly alongside Core.

The important thing is that I’m now working through the practical setup rather than simply researching the possibilities. There are decisions to make about licensing, renewals, software delivery and the experience of someone purchasing Premium for the first time.

It’s an interesting change of emphasis. I’ve spent a considerable amount of time building the software and developing the systems around it, but commercial distribution brings a different set of requirements. The product needs to be understandable, purchasable and maintainable, as well as technically capable.

I’m definitely going to take some time out next weekend but in the meantime, there’s still plenty to do, particularly getting the commercial side of Niche Clever Interactive into a state where I can begin selling it.

OpenAI model costs compared

Standard token-based prices in US dollars per million tokens, checked 16 November 2026. Relative output cost is measured against GPT-6 Luna (1×).

OpenAI model pricing comparison
Model Input / 1M tokens Cached input / 1M tokens Output / 1M tokens Relative output cost
GPT-6.1 Sol $2.00$0.10 $10.0020×
GPT-6.1 Terra $1.00$0.05 $5.0010×
GPT-6 Astra $10.00$1.00 $50.00100×
GPT-6 Sol $2.00$0.20 $10.0020×
GPT-6 Luna $0.10$0.01 $0.501×
GPT-5.6 Sol $4.00$0.40 $20.0040×
GPT-5.6 Terra $2.00$0.20 $12.0024×
GPT-5.6 Luna $0.20$0.02 $1.202.4×

These are standard token rates, not per-message charges. Other processing modes, long-context requests, tool calls and subscription usage limits may affect actual cost. GPT-5.6 Sol pricing is promotional and may change after 21 November 2026. Source: OpenAI ChatGPT rate card .

OpenAI models: strengths and weaknesses

A practical comparison for software development, research, writing and everyday technical work. These are qualitative assessments rather than guaranteed benchmark outcomes.

Practical strengths and limitations of OpenAI models
Model Strengths Weaknesses and limitations
GPT-6.1 Sol Strong complex coding, architecture, multi-stage reasoning and demanding professional work; good balance of capability and cost. More resource-intensive than Terra or Luna; not the highest-capability option for exceptionally difficult problems.
GPT-6.1 Terra Fast and efficient for visual reasoning, computer interaction, clear writing, interface work and targeted code changes. Less suited than Sol or Astra to the hardest architectural decisions, intricate debugging and extended reasoning.
GPT-6 Astra Highest overall capability for difficult reasoning, software engineering, complex debugging and research synthesis. Highest token cost in this comparison; can be excessive for routine tasks and may take longer to respond.
GPT-6 Sol Strong coding, agentic workflows, technical problem-solving and professional tasks. Earlier Sol generation; GPT-6.1 Sol has the same standard input/output rates and cheaper cached input.
GPT-6 Luna Lowest cost; suitable for summaries, extraction, categorisation, repetitive work and small, well-defined edits. Less dependable for ambiguous requirements, difficult reasoning or decisions affecting multiple systems.
GPT-5.6 Sol Capable professional coding, structured research and established technical workflows. Higher token prices than GPT-6.1 Sol, making it less attractive for new general-purpose workloads.
GPT-5.6 Terra Competent everyday writing, visual interpretation and straightforward coding work. Older and generally less economical than GPT-6.1 Terra for comparable tasks.
GPT-5.6 Luna Lightweight summaries, categorisation and small routine tasks. Higher token cost and generally less capable than GPT-6 Luna.

Model strengths and limitations are editorial assessments informed by OpenAI’s model documentation . Results vary according to task, prompting, tools and reasoning effort.

Export and share