Notes on context engineering, AI agents and AI economics

A language model can write a convincing paragraph about a compound it has never reasoned about. Discovery needs reasoning that persists, can be checked and improves with every experiment.

The most valuable finding in a field is often a contradiction no paper states. Why summaries hide it, and how holding every claim with its conditions brings it out.

A hypothesis is only as good as its weakest step. Built as an explicit path, every link sourced, it can be reviewed in minutes, and the next experiment chosen on purpose.

A research loop that starts every cycle from a blank state is automation, not research. What makes R&D autonomous, why agents alone fall short, and where it applies.

When a system runs research on its own, the most important output is the reasoning that led to the result: kept, replayable and open to audit.

Your assistant is excellent at code it has never seen and unreliable about code you wrote yourself. The cause is structural: the distance between the way you asked and the form the tool can compute over.

A practical protocol for testing AI code tools yourself: designing the question set, holding the model constant, blind scoring, and the four things worth measuring.

Cost per token is a supplier's metric. The number that discriminates between AI tools is how much correct reasoning you get per unit of context — and the spread across tools is elevenfold.

What the Model Context Protocol actually is, why it turns an N×M integration problem into N+M, and the question to ask a vendor that 'we support MCP' does not answer.

Impact analysis fails because reference lists answer at the wrong altitude. What a useful answer contains, why it must run in both directions, and how to improve this without new tooling.

Seat pricing broke when every request started costing the vendor money. A survey of what the market charges for now — agent compute, credits, per-action — and how to read a bill before you sign it.

Encryption describes how data is protected in transit. It says nothing about whether the data goes anywhere. The three deployment shapes, and the questions that settle a security review.

Vendor architecture slides are unfalsifiable, and treating them as evidence is the most common mistake in AI procurement. What counts as evidence, and six questions for a vendor call.

Most engineers talk to AI the way they talk to a search box, and lose answers they could be getting today. Six question patterns worth copying, and how to tell a good answer from a fluent one.

The dangerous AI answer is fluent, specific, plausible and wrong in a way you will not discover for three weeks. Detecting those is mostly mechanical. Here is the mechanism.

A randomised controlled trial found experienced developers were 19% slower with AI — while estimating they were 20% faster. The detail everyone skips explains why.

Support, product, engineering and finance describe one fact in four vocabularies with no shared object connecting them. Every handoff is a translation, and 64% of defects originate there.

96% of developers do not fully trust AI-generated code to be functionally correct. Somebody has to check, that checking is work, and it appears on no invoice.

Developers spend 58% to 70% of their time understanding code, not writing it. The industry spent three years optimising the smaller half — and increased the load on the constraint.

Four months to productivity on a senior hire is roughly $60,000 spent on an activity nobody has defined or measured. It is not a hiring problem — it measures what understanding your system costs.

Handover documents fail for a reason that is not laziness: the departing person does not know what they know. Expertise is retrieved by situation, not enumerated on request.

Most engineering dashboards were designed for a world where producing code was expensive. Six numbers that still mean something, and three things to stop reporting.

'Is this risky?' is answered several times a week by the person who has been there longest. Nobody records the reasoning. Your most consequential decisions run through an oracle with no audit trail.

The standard slide — 90% adoption, 40% self-reported productivity, annualised to millions — will not survive a numerate board member. Here is an answer that does.

Adoption is over at around 90% and proved little. The four positions in the market, what pricing reveals about cost structure, and buying advice for this quarter.

An LLM can generate code, but most of what it 'knows' about your product stays implicit — hidden in weights, scattered across prompts, buried in code, stored in someone's head. GitMir turns that hidden context into an explicit, living graph so AI agents build against the system, not isolated prompts.

Most legacy migrations fail because nobody fully understands the system being moved. The fix isn't translating code — it's capturing the product as a structured model first, so AI can re-platform and refactor it with real context.

NVIDIA's Spark and the AI PC signal a shift: AI agents are moving onto the machine — always-on, local, next to your code. Why that makes architectural visibility non-negotiable.

The AI conversation is maturing from "AI will take your job" to "where's the real business value?" Why generation alone isn't enough — and why the future is human-first, visible AI.

Vibe coding means building software by prompting AI instead of writing code by hand. It's fast — but without structure it ships bugs, lost context and hidden architecture. Here's how to keep the speed and the control.

Cursor and Copilot make you faster at writing code. GitMir makes your whole system visible and controllable. Here's how they compare — and when you need more than autocomplete.

AI coding bills scale with tokens, and ad-hoc prompting burns them fast. Here's why token spend explodes — and the pipeline changes that cut it dramatically.

AI doesn't 'hallucinate' randomly — it invents code when it can't see the system. Give it structure and validation, and the hallucinations stop being your problem.

The teams winning with AI aren't the ones prompting hardest — they're the ones who can see what AI builds. Here's the architecture-first way to ship complex products fast and safely.

AI-native development means building software where AI is the primary builder and humans direct, review and architect. Here's what changes, what stays, and how to do it without losing control.

An AI coding agent plans and executes multi-step coding tasks on its own. Powerful — but without structure and validation, autonomy amplifies mistakes. Here's how to use agents safely.

AI writes confident code that's sometimes wrong. A repeatable validation process catches the failures before production. Here's a practical checklist plus the system-level fix.

Vibe coding gets you a working prototype fast. Turning it into something you can run, scale and maintain is a different job. Here's the path from demo to durable product.

Architecture docs go stale the moment they're written. The fix isn't more discipline — it's making the architecture itself the living source of truth. Here's how.

New engineers spend weeks just figuring out how the system fits together. Visual architecture cuts that to days. Here's why onboarding is slow and how to fix it.

Cursor is a great AI editor, but it's not the only — or always the right — choice. Here are six alternatives, what each is best at, and when you need more than an editor.

Copilot is excellent autocomplete — but autocomplete has a ceiling. Here are the alternatives for teams who need multi-file edits, agents, or full architectural control.

Lovable generates apps from prompts, fast. GitMir gives you a visual, controllable system for complex products. Here's how they differ and which fits your project.

v0 is brilliant for generating UI from prompts. GitMir builds the whole system — architecture, logic, data — visually and under control. Here's how they compare.

Replit Agent builds and runs apps autonomously in the browser. GitMir gives you a visual system you direct and validate. Here's the trade-off and which fits you.

Bubble is mature visual no-code. GitMir is AI-native: visual architecture plus AI that builds inside it. Here's how they differ for serious products.

There's no single best AI coding tool — there's the right one for your job. Here's a clear-eyed guide to the categories and top picks for speed, agents and control.

Startups need to ship fast without building a mess they'll pay for later. Here are the AI tools worth using at each stage — and how to avoid the scaling trap.

AI-built codebases can rot quietly until a small change takes a week. Here are seven early warning signs — and what to do before it's a rewrite.

Vibe coding feels free — until you count the rework, the token bills, the onboarding drag and the rewrites. Here's the real cost, and how to keep the speed without it.

AI lets your team ship faster — and accumulate invisible risk faster. Here's how CTOs capture the speed while keeping architecture, quality and cost under control.