The Senior Architect

Spotting Hidden Costs

AI models are trained on average code. Often, they suggest the "easiest" way to solve a problem, which isn't always the most efficient. Because you understand Big O notation (Week 30) and how the CPU cache works (Week 3), you can spot when an AI is about to tank your app's performance.

// AI Suggestion: Searching for a user in a large list every frame.
auto it = std::find_if(users.begin(), users.end(), [&](const User& u) {
    return u.id == targetId;
});

// Senior Architect Review: "This is O(N) inside a 60FPS loop. 
// We should use a std::unordered_map for O(1) lookups."

Security and Memory Safety

AI can be dangerously confident about memory management. When bridging C++ to Swift or C#, the AI might forget to free a buffer or might assume a pointer remains valid across an asynchronous call. Your knowledge of pointers (Week 17) and RAII (Week 24) allows you to audit these bridges for stability.

A senior architect doesn't just see the code that is there; they see the edge cases, the race conditions, and the memory leaks that aren't there yet.

The audit checklist

Patterns that an LLM regularly slips past you, in roughly the order they cause trouble:

• Quadratic loops in hot paths. Nested for over a list inside a render or per-frame call. Often fixable with a hash map populated outside the loop.
• Returning pointers to local variables. Particularly when the AI writes a C-style API on top of std::string. The pointer dangles the moment the function returns.
• Silent allocations. A range-for that copies, an implicit std::string from a literal, an std::vector::push_back in a tight loop without reserve. Each one looks innocent.
• Missing const and missing noexcept. Both are contracts the rest of the codebase relies on. Their absence shows up as confusing compile errors elsewhere.
• Race conditions. An AI happily writes to a shared variable from a background queue without a lock. The bug appears once a year, in production.
• Wrong error model. Throwing exceptions across an extern "C" boundary. Returning std::optional from a function the caller assumes returns success codes. Mixing the two in one module.

The audit isn't pessimism — it's the exact same mental pattern as code review for a junior teammate, just applied to a teammate that produces a hundred lines a minute.

Structural Integrity

AI tends to solve problems in isolation, often leading to "spaghetti code" over time. As the architect, you ensure the AI follows established design patterns (Week 23). You dictate the interfaces and the ownership models, and you force the AI to implement its logic within those guardrails.

// User instruction to AI:
// "Don't add the database logic to the View. 
// Create a repository pattern where the View observes 
// the ViewModel, and the ViewModel calls the Repository."

What's next

Auditing code is one thing; letting an AI autonomously solve complex tasks is another. Next week, we'll explore Agentic Workflows: how to set up multi-step AI systems that can research, implement, and test features with minimal intervention from you.

Week 50 is Agentic Workflows.