Five different kinds of use, and the distance between them is the point.

Evaluation before adoption, from 2022 at the City of Jacksonville. As enterprise architect, high-level technology review and systems analysis of where AI could and could not fit a consolidated city-county government — vendor briefings and capability assessment against the estate as it actually stood, running from 2022 until departure in 2024. Nothing was implemented, and that is the honest description: the work was to establish what would be defensible before anything was bought. In a government estate carrying public safety, criminal justice and public records obligations, the constraints arrive first — retention, disclosure, CJIS boundaries, and what a public body can stand behind when asked how a decision was reached. Most of the assessment was about which of those questions had answers yet.

The same posture, on the private-sector side, produced the AI-analytics evaluation inside the gunshot detection and active-shooter tracking pilot in 2023 — current and emerging detection and classification models assessed against a seconds-not-minutes requirement, taken to vendors and industry principals rather than to a brochure. Feasibility work of this kind is worth more when it ends in a defensible no than when it ends in a purchase.

Design and identity, from 2023. The first work was commercial rather than technical: generating and iterating the Young Tech Systems brand marks. An unglamorous starting place, and a useful one — it is where the gap between a plausible first output and a usable final one is most obvious, and where you learn that the skill is in the critique rather than the prompt.

Document and workflow production, through the NRI tenure. Drafting, restructuring and reviewing at volume: proposals, design documents, assessments and the ordinary correspondence load of a director role. Time recovered here is the least interesting claim on this page and the one with the most hours behind it.

Integration into orchestration — the part worth stating carefully. Claude APIs integrated into network orchestration workflows on the Itential platform, worked alongside the orchestration vendors. This is where the applied work started and why it continued. Specific client implementations sit under nondisclosure, which limits what this paragraph can say; what it can say is the shape of the work.

It sat on the vendor side of the problem rather than the consuming side: not “we used a tool”, but sitting with the people building the tool while they worked out what the model could be trusted to do inside an automation pipeline, and what it could not. Given that automation multiplies the blast radius of a mistake, a language model inside an orchestration path is a governance question before it is a capability question.

Prompt design and tool definition, as a working practice rather than an interest. Across Claude, ChatGPT, Gemini and Grok. The applied end of it is cryptographic asset discovery and change-at-scale planning — the parts of a problem where the volume of state defeats manual review, and where the model is doing classification and enumeration rather than judgment.

And the crypto-assessment work, the narrowest and most defensible of them: discovery and inventory of cryptographic assets across large estates, classification of what was found against replacement priority, and change-at-scale planning. These are the parts of the post-quantum problem where the volume defeats manual review. Specific client implementations sit under nondisclosure.

How the work actually goes

The uses above are outputs. The method underneath them is the part that transfers, and it is easier to show than to assert, because this record is itself an instance of it.

This site was designed and built that way over five months — a derived content graph, five schema-enforced collections, an access-controlled document store, four charts generated from the same declarations that generate the indexes. So were the financial model and business plan behind Young Tech Systems: a monthly cash model built, then broken deliberately, then rebuilt when an assumption in it turned out to be flattering rather than true. In that case the founder’s own billing ramp had been modeled at a level the trading history did not support, which moved the capital requirement by roughly $40,000 in the wrong direction. It was found by asking for the model to be attacked rather than reviewed.

That is the working pattern, and it has three parts.

State the constraint before the solution. Most of the wrong answers arrive because the question was underspecified, not because the model was weak. Mail stays on the incumbent nameservers; the record has to outlive its host; the founder is not going to be the only person in the plan underwriting it out of his own salary. Constraints stated first close off whole families of plausible, useless output.

Push back on the answer, not just the prompt. The useful loop is adversarial: produce a draft, hand it to a second model with instructions to find what is wrong with it, then fix what survives scrutiny and reject what does not. Several of the numbers in the Young Tech Systems packet exist in their current form only because a critique found an arithmetic convention applied inconsistently across two tables. Neither the drafting model nor the critiquing model caught it alone.

Own the verification. The judgment about whether an answer is right stays with the person, which means building something that can check it — a verify pass over the site that counts the marks each chart draws against the collection it draws from, a decomposition of the cash trough that has to sum to the figure the spreadsheet reports at that month. The check is the deliverable as much as the artifact is; assistance without a check is just faster guessing.

And the finding that came out of pushing it hardest. Modernizing a legacy industrial system, rebuilding its reference data rather than its code was the most demanding instance of this method so far, because the artifacts were binary and the failure mode was silent: a converted file that loads, runs, and returns a subtly wrong answer. Acceptance criteria were fixed before anything was generated, and every artifact was verified against the original by exact byte-for-byte round trip rather than by reading it, because inspection is the check that feels best and scales worst.

What it established is the sentence worth carrying into any plan of this kind: the binding constraint is expert review capacity, not generation capacity. Generation is cheap and getting cheaper; establishing that a given artifact is correct is neither. A program that budgets those the other way round produces more than it can defend, and in engineering work that is worse than producing nothing.

None of that is a claim to be doing anything unusual with the tools. It is a claim about where the engineering judgment sits, which is where it has always sat.

On breadth, and on what this does not claim

The practice runs across ChatGPT, Gemini, Grok and Claude rather than one of them. That matters less as a boast than as a working position: using four means being able to speak to where they actually differ, which is not a thing anyone can do from a single vendor’s documentation.

What this page does not claim is that any of it is novel. Plenty of people have been doing the same since the same year. The claim is narrower and checkable — that the assessment work runs from 2022 and the tooling has been in daily hands-on use since 2023, across design, document production, orchestration integration and cryptographic assessment — a wider span than most enterprise architects have covered — and that the vendor-pilot work sits on the side of the table where the constraints are decided rather than inherited.