The USAF’s Collaborative Combat Aircraft recent updates got me thinking about AI in software engineering. I spent my Air Force career securing information systems. Not flying them. But after decades in aviation, the Loyal Wingman concept hits different when you are building software.

Grew up a military brat near air bases, hearing afterburners crack overhead. I joined the Air Force for information security, not the flight line. Closest I got to the cockpit was securing the systems behind it. Working in aviation most of my adult life makes the Loyal Wingman analogy for AI less of a stretch and more of lived experience.

The Program

The United States Air Force runs Collaborative Combat Aircraft, or Loyal Wingman. Crewed fighters like the F-35 pair with autonomous drones that absorb risk, extend sensor reach, execute tactics without burning a human life.

Anduril Industries YFQ-44A and Boeing MQ-28 Ghost Bat are force multipliers. One pilot controls multiple aircraft. Human sets strategy. Drones do the work.

An F-35 costs ~$80m per unit while XQ-58A runs around $4m. Lose three drones and still cheaper than scratching one F-35. This is not about replacing pilots. Giving them capability without proportional cost increase.

The Air Force recently selected both General Atomics and Anduril for production contracts, with autonomy software vendors competing through a six-month performance test before a final down-select in summer 2027. The program has moved from concept to operational testing faster than anyone predicted.

The Core Lesson for Senior Developers

Core lesson for senior developers: AI should amplify output without turning you into an auditor of every line. When it works, force multiplication. When it fails, wasted cycles reviewing mediocre code.

► Pilot defines mission objectives. You define architecture.

► Drone absorbs risk. AI handles legacy refactor nobody wants.

► Sensor fusion feeds unified picture. AI scans repo, correlates deps, flags security debt.

► Human retains kill authority. Review every line before shipping.

Where AI Actually Works

AI works on mechanical, repeatable tasks. Let it take first pass on legacy modules. Catch mistakes in review. You lose a commit, not your career. Scanning repos, correlating dependency chains, flagging vulnerabilities faster than manual audit is where AI earns its keep.

This is the same principle I wrote about in my CMMC post. Supply chains were the attack surface because nobody had visibility into what lived downstream. The intelligence gatherer role suits AI well. It is not writing your architecture. It is feeding you the tactical picture.

Where Teams Fail

Teams fail treating AI as black box that ships to production. You become spectator. Spectators make poor decisions.

► Bad pattern: Copilot writes feature, you merge, do not understand dependency graph.

► Good pattern: You define interface, AI scaffolds, you review and integrate. Stay in the loop as pilot.

The Loyal Wingman works because the drone is specialised. It does not fly the jet for the pilot. It flies alongside. Your AI stack needs that discipline. Do not ask it to build the app. Ask it to generate the migration script for the user table. Write the regex for log parsing. Scope the mission. Define the ROE.

The Economics Question

Air Force bets on collaborative autonomy. Cheaper units protect expensive ones. Clear roles. Measurable outcomes.

For developers, the math is different. You pay for tooling. Copilot licence. Enterprise platform. Whatever stack you choose. But if it saves you hours each week and you apply that time to higher-value work, the ROI materialises. The trick is knowing which tasks warrant AI involvement and which demand your full attention.

Junior developers often benefit most from the scaffolding AI provides. It fills experience gaps. Lets them move faster. Learn patterns. Senior developers should use it differently. Delegate the mechanical work. Retain the architectural decisions. Automate the routine. Stay sharp on the critical path.

When scoped correctly, AI reduces friction rather than creating new work to manage it.

What Actually Matters

For senior developers:

► Command mission. Define clearly. Ambiguity kills in air and codebase.

► Delegate selectively. Offload boring tasks. Keep architecture and security decisions.

► Verify everything. Never trust wingman without checking instruments.

The Air Force learned this with early UAVs. Too much automation caused friendly fire. Loss of situational awareness. The operator became a spectator. Spectators make poor decisions. Teams make the same mistake with LLMs right now.

Treat AI as replacement, you fly solo. Treat it as specialised tool with clear boundaries, you gain capability without sacrificing control.

HOTAS (or HOKAM?). Full stop.