Posts

Two leading language models pulled a white paper in opposite directions. The useful workflow uses both, then puts human judgement back in charge.

A Rubik's Cube, Mahler's Ninth and a slow data warehouse all point to the same skill: building internal models that connect representation, reality and judgement.

APIs are right for business interaction, but audit, analytics, synchronisation, active-active operation and recovery need patterns chosen by purpose.

Vector stores and agent memory inherit the governance problem of external storage. AI context should not become an ungoverned parallel truth.

My father already knew his trade in his hands. Becoming a lecturer meant serving a second apprenticeship on top of it — and what he taught me in a darkened living room was never really about roof trusses.

Object storage should not be the default for governed enterprise content. It creates separate security, recovery, audit and consistency boundaries.

Sagas and eventual consistency were designed for bounded failure modes. Non-deterministic agents force us to re-examine transaction boundaries.

A wonky shelf looks wonky. But the most celebrated engineers have built magnificent structures with fatal flaws nobody could see. Software has always had that problem, and unsupervised AI takes it somewhere genuinely unknown.

Agents can create plausible, structurally valid, semantically wrong data at scale. Integrity needs controlled write surfaces and database-enforced invariants.

Agentic access breaks the link between end-user identity, query scope, authorisation and audit. The database needs to know more than a service account.

AI can do the beginner work. That is exactly the problem, because the beginner work is how beginners became experts. Construction already ran this experiment, and the bill arrived decades later.

The application layer has long been the practical gatekeeper for enterprise data. Agents weaken that assumption and put pressure back on the database boundary.

Why AI-enhanced phishing means the old scam-spotting rules are no longer enough, and why ordinary households need to verify the route, not the writing.

Email is no longer just where messages arrive. It is recovery infrastructure for banks, cloud services, phones, password managers and everyday identity.

AI makes one skilled person extraordinarily productive. But a business needs more kinds of judgement than any one person holds, and that is the constraint the hype quietly ignores.

Schemas describe shape, but agents need meaning. API contracts need domain intent, authority, provenance and behaviour, not just valid payloads.

AI is most useful before coding starts: expanding the problem space, surfacing assumptions, and helping shape better decisions before implementation narrows the options.

SOA's real lesson for agent-era APIs is that structural contracts are not enough. Interfaces need meaning, behaviour, authority and governance built into the contract.

AI has changed the economics of moving a blog: the hard part is no longer the migration work, but knowing what you want to build.

Agents and MCP do not replace APIs. They expose whether the execution layer underneath them is explicit, stable and safe enough to compose dynamically.

AI coding tools change the economics of software work, but they make judgement, craft, testing and responsibility more important rather than less.

AI agents expose the integrity, rollback, query and context-window costs of over-applied microservices in systems that never needed that complexity.

Building a useful GPT is less about clever prompting than treating it as a small software project: source material, structure, tests, iteration and version control.

A Friday Coffee reflection on building a VHF antenna, old technical books, patient learning, and the pleasures of finding things out slowly.

Why cloud sync is not the same as backup, and what that means for photos, documents, ransomware, account loss, and everyday resilience.

Why Apple, Facebook, and other account logins deserve the same permission review as Google when checking your digital exposure.

A personal reflection on how AI agents have made ambitious software work feel possible again after decades in technology.

Why connected apps and third-party permissions on your Google account deserve regular review, even when your password is secure.

Why Apple Pay and Google Pay reduce card exposure online, and why tokenised payments matter for everyday digital safety.

Why replacing a debit card with a credit card or tokenised payment method can reduce personal financial risk online.

Why NVIDIA’s AI architecture story is strong on compute and infrastructure, and why the data boundary still needs separate architectural attention.

How AI exposes the boundaries between infrastructure, data, security, and governance rather than simply creating a new infrastructure problem.

How AI coding tools may change the role of developers, shifting more value toward design, judgement, specification, and review.

A personal reflection on keeping up with fast-moving AI tools without confusing constant novelty with durable understanding.

Why AI security tools may reveal weak engineering practices faster than they improve them, and what that means for architecture and risk.

A practical argument for using AI in software delivery through exploration, canonical specs, review, and controlled implementation.

What claims about AI agents coding for hours really mean, and why useful software still depends on architecture, judgement, and tight feedback loops.

AI can write SQL for you and run it immediately. That is useful, but it also changes the risk boundary around database access.

A hands-on walkthrough for configuring Auth0, creating an ORDS JWT profile, and securing an endpoint on Autonomous Database.

Why Auth0 and ORDS fit together cleanly when Auth0 acts as identity provider and ORDS protects database-backed APIs as a resource server.

Why SQLcl can be a better fit than MCP when AI coding tools need repeatable Oracle database scripts and build workflows.

Why AI agents make explicit business rules, assertions, and enforceable constraints more important, not less.

Why LLM-driven agents need data security enforced below the app layer, close to the database and user identity.

How agent skills can capture Oracle database best practice so AI-generated applications are not limited by stale training data or weak public examples.

How data lakes, operational reporting, and enterprise BI can coexist when each layer is clear about freshness, modelling, and audience.

A starting point for thinking about where generative AI can help data professionals, and where messy data still needs human judgement.

How MCP can connect AI tools to Oracle SQL, and why database access still needs boundaries, review, and engineering discipline.

A sceptical look at when microservices and DevOps help, and when business complexity still calls for design-led architecture.

How APIs, microservices, and multi-model data platforms can reduce the old tension between object and relational views of data.

Why developers, DBAs, and analytics teams need different views of the same data, and why the tension is structural rather than personal.

How to move useful discoveries from a data lab into a mission-critical data warehouse without losing the agility that created them.

A comparison of storage patterns for read-only big data systems, especially where current views and history both matter.

Why operational reporting and enterprise BI need different data patterns, freshness expectations, and architectural trade-offs.

A reflection on what enterprise architecture is really for, and why diagrams and tools matter less than useful architectural judgement.

Practical guidance on making data lakes, warehouses, marts, and data science environments work together around business needs.

Why becoming data-driven is an organisational and architectural challenge, not simply a matter of adopting big data technology.

Why treating data as an asset requires a managed platform, clear governance, and more than on-demand database provisioning.

A Friday Coffee reflection on fashion-driven IT, technology hype, and the need for more scepticism in architecture decisions.

How GDPR changes the persistence choices behind microservices, especially when customer data needs shared governance and control.

Why data security needs to move beyond perimeter defence and focus directly on confidentiality, integrity, and availability.

How end-to-end business processes expose coordination challenges across microservices and enterprise systems.

How orchestration and choreography shape microservice coordination, and why the right pattern depends on business process integrity.

A December note on enterprise architecture, seasonal quiet, and making time to learn and reflect.