Journal

OpenAI's GPT-5.6 Luna started with a scripted test that defined a verifiable goal. Across iterative pull requests, it corrected course and kept working until the capability held up. Watching that feedback loop become real was genuinely cool.

Part of the work was making the summary less technical. I asked Luna to explain the completed epic in a tone reminiscent of People magazine writers, and that prompt helped trim the jargon without hiding the careful boundaries.

DeepSeek V4 Flash in OpenCode felt similar to my experience with OpenAI GPT 5.6 Sol in Codex. That is a personal observation from this one focused session, not a comparison of either tool's performance or quality.

The results looked pretty good to me. Some of the language it generated was a little choppy and included run-on sentences, but for a simple task like adding a new Public Work page to the consulting site, it worked out OK.

The Antigravity CLI felt similar to Codex in its overall structure: a series of prompts, confirmations, and model-generated changes reviewed before they land. That similarity made it easy to pick up. The main difference I noticed on first use was the number of permission prompts. That was expected for a first session — a new harness needs to learn my defaults before it can operate with less friction.

The Gemini 3.7 Flash model ran noticeably fast and gave responses that felt appropriately direct. I also found the documentation less wordy than my experience with GPT 5.6 Sol. That is a personal observation from one session, not a benchmark, but it was enough to make the tool feel productive for the kind of focused implementation work I was doing.

I used the Antigravity CLI to create a pull request that aligned the bootstrap IAM policies and parameterized deletion protection across the Aurora cluster and DynamoDB coordination table. That work completed the live AWS deployment lifecycle verification for Milestone 2 of the delivery orchestrator.

I tried Codex's approval mode after becoming impatient with repeated requests for input. Based on the usage data I saw in the Codex admin dashboard, my own observation was that credits were being consumed at roughly five times the rate I expected. That is one week of personal usage, not a general claim about the product, but it was a useful reminder to pay attention to how an AI tool is operating and being used.

When I needed to update IAM policies without Codex available, I had to read through AI-generated Terraform and documentation to understand what was happening. The work was slower, but it reinforced a practical lesson: I still need to stay close enough to AI-generated changes to review them, question them, and take responsibility for the decisions they support.

I also used GitHub workflows to create the AWS resources for the delivery-orchestrator experiment and to remove them afterward. Being able to take the environment down when I am not using it gives me a clearer way to control costs while I continue learning.

The goal is not to keep infrastructure running simply because it exists. I want to use it deliberately, learn from a bounded experiment, and leave room to change direction as the workflow becomes clearer.

I am continuing to focus on the ai-delivery-orchestrator as a place to test more agentic AI usage. The week did not produce a finished answer about the right level of automation. It did make the boundary clearer: useful AI assistance depends on active human oversight, understandable changes, and attention to the resources the workflow consumes.

I added a way for the automation to split work that had grown too large into smaller issues. The split worked, but the new issues were created by the automation itself. That origin did not satisfy the trust rules for the next planning step, so the workflow either blocked the children or failed instead of moving them forward.

That was frustrating because the detour sat beside the feature work I wanted to finish. It was also useful evidence: in a label-driven system, every transition has consequences. Creating the right issue is not enough if its labels, history, and permissions leave the next stage unable to act.

I am still using the consulting client portal as an incubator for these ideas. It gives me real implementation work against which to test planning, splitting, approval, coding, and recovery without pretending the automation is finished or production-ready.

The imperfect journey is part of the work. Each bump makes the boundaries between human judgment and automated action more explicit, and each recovery teaches me what the workflow must make visible before I can trust it with a larger role.

The longer-term goal remains a human-directed AI delivery factory: I want to spend more of my time defining the problem, reviewing the plan, and making consequential decisions, then give well-prepared work to an AI-assisted implementation process.

I expect more side quests along the way. For anyone following a similar path, the practical lesson is to stay positive and focused on the outcome while treating failures as information. Progress is not a perfect sequence of successful runs; it is the accumulated judgment to make the next run safer and more useful.

Making a repository public is different from making its contents approachable. The new planning showcase renders the existing Markdown records for the browser, organizes them by initiative, and provides direct paths to presentation-oriented material such as the client portal storyboard and wireframe gallery.

Markdown remains the source of truth. Publishing it through GitHub Pages avoids maintaining a separate copy while giving me stable links I can use in conversations and in this public-work portfolio.

Plans are useful evidence when they show assumptions, alternatives, revisions, boundaries, and the points where a person made a decision. Sharing that record gives others something more concrete to evaluate than a polished result with the reasoning removed.

The showcase contains sanitized, fictional, or generalized material. It is not a record of a completed client engagement, proof of a business outcome, or a claim that every planned capability is implemented or production-ready.

The local implementation now has foundations for authentication and tenant isolation, along with bounded human access and read-only machine access. It includes invitation-only onboarding, client invitation acceptance, and an accessible staff interface for managing the invitation lifecycle.

The useful lesson was that authentication alone does not grant someone access to an organization. The workflow also needs an explicit relationship between a person, an invitation, and the organization they are permitted to enter.

Implementation also strengthened the surrounding safeguards: CI and integration testing, clearer approval evidence, credential scanning, recovery guidance, and human-gated agent workflows. Those are practical controls for changing a system carefully, not a substitute for human judgment.

This is a working local vertical slice using fictional fixtures. It is not an MVP launch, hosted staging environment, production onboarding system, or client deployment. Completing a useful local flow makes the next questions more concrete; it does not establish production readiness.

The next implementation milestone is disposable end-to-end Playwright browser coverage for the onboarding flow. That work is not yet approved or complete, but it would help test the visitor-facing path without treating the local slice as ready for client use.

The first proposal was technically coherent: an AWS-centered client portal with custom infrastructure and transaction workflows. But it asked one project to serve clients, deepen my AWS experience, handle signing and invoicing, and create AI-learning opportunities before I had validated the business process.

I asked AI to challenge that direction rather than refine it. Its counterproposal made the tradeoff clear: building authentication, infrastructure, electronic signatures, and invoicing myself would add risk and ownership cost without much strategic value for the AI learning I wanted from this work.

I reviewed that critique, asked follow-up questions about vendor exposure, portability, recovery, and cost estimates, and made the decisions. The revised direction uses Stripe for invoicing, an external provider for electronic signatures, Vercel for the Next.js application, Supabase for PostgreSQL, authentication, and storage, and JSON:API for a reusable standards-based frontend and backend contract.

Those choices delegate commodity transactions where owning them would create an unfavorable risk or maintenance burden. They leave more room to learn from the workflow and make deliberate decisions about the parts that matter to the business.

The revised plan is complete as a planning artifact, and I intend to begin implementation within the next few days. The portal has not been implemented, validated with clients, or put into use.

The useful part of this AI-assisted process was not accepting a first answer. It was asking for a counterproposal, testing the reasoning with questions, and retaining responsibility for the goals, tradeoffs, vendor choices, approval, and decision to proceed.