How to Leverage AI as a Thinking Partner for Managing Large-Scale Engineering Systems

Introduction

As an engineering leader overseeing hundreds of repositories, the cognitive load of synthesizing legacy context, pressure-testing designs, and making high-level architectural decisions can be overwhelming. Julie Qiu, a seasoned engineering leader, describes how AI can serve as a "thinking partner" that extends your mental capacity—providing the extra "RAM" needed to manage complexity. This guide breaks down her approach into five distinct roles—Archaeologist, Experimenter, Critic, Author, and Reviewer—and provides step-by-step instructions for integrating AI into your workflow. By following these steps, you'll reduce cognitive strain, accelerate decision-making, and maintain high-quality standards across your organization.

What You Need

• An AI assistant tool (e.g., ChatGPT, Claude, GitHub Copilot, or a specialized engineering AI) with access to your code repositories and documentation.
• Familiarity with the architecture of your largest or most complex systems (at least high-level context).
• A list of the 400+ repositories or equivalent scale—prepare a high-level index of their purposes and interconnections.
• Clear design documents or RFCs for any new features or changes you are evaluating.
• A testing environment or sandbox where you can safely run AI-generated code or designs.
• Time for iterative refinement: allocate 30-60 minutes per role per week, though you can compress as you become proficient.

Step-by-Step AI as Thinking Partner

Step 1: Assume the Archaeologist Role

Purpose: Use AI to uncover and summarize legacy context across hundreds of repositories quickly.

1. Provide the AI with a curated list of the most important repositories (start with 10-20 that are highly interdependent). Use natural language to describe the problem you want to solve (e.g., "I need to understand how the authentication service is tied to the user profile repository").
2. Ask the AI to generate a summary of each repository: its purpose, key files, and relationships to others. You can feed in README files, architecture docs, or even code snippets.
3. Combine outputs into a cohesive map. For example, ask: "Create a diagram or specification of how these five services communicate." The AI can help surface forgotten dependencies and deprecated modules.
4. Use this synthesized context to inform your architectural decisions. The AI saves you from manually reading thousands of lines of legacy code.

Step 2: Assume the Experimenter Role

Purpose: Pressure-test design ideas and explore alternatives without writing all the code yourself.

1. Describe your proposed design to the AI in detail. Include constraints, latency requirements, and non-functional needs like security or scalability.
2. Ask the AI to generate multiple variations of the design, including edge cases and trade-offs. For example: "Show me how the database sharding strategy would work if we used range-based partitioning vs. hash-based partitioning."
3. Have the AI simulate the performance or behavior of each variation. You can provide mock data or ask for expected results.
4. Compare the outputs with your mental model. The AI acts as a rapid prototyping partner—it may suggest approaches you hadn't considered, helping you avoid costly mistakes.

Step 3: Assume the Critic Role

Purpose: Use AI to rigorously challenge your assumptions and catch blind spots early.

1. Present your finalized design (from the Experimenter role) to the AI, asking it to play the devil's advocate. For instance: "Identify the top five risks in this architecture, assuming we have a team of ten engineers."
2. Ask the AI to produce a list of plausible failure scenarios: e.g., network partitions, data inconsistency, or upstream API changes.
3. Request a comparison of your design against well-known patterns (e.g., CQRS, Event Sourcing, microservices vs. monolith). The AI can highlight where your approach deviates and whether those deviations are intentional or risky.
4. Incorporate the AI's critiques into your decision. You may decide to revise the design or add safeguards. This step acts as a low-cost code/design review before you involve human engineers.

Step 4: Assume the Author Role

Purpose: Let AI draft documentation, code skeletons, and migration plans based on the agreed design.



1. Provide the AI with the final design summary (post-critique). Ask it to generate an RFC document outline, including sections for requirements, architecture, trade-offs, and rollout plan.
2. Expand each section with detailed paragraphs. You can ask the AI to write in a style consistent with your team's documentation conventions. For code, request function signatures or pseudocode for the core components.
3. Review the AI's output for accuracy and completeness. The AI may invent details—validate them against your knowledge. Adjust the prompt to get better results (e.g., "Add error handling patterns for each function").
4. Publish or share the generated content with your team. The AI saves you hours of writing, letting you focus on high-level ownership.

Step 5: Assume the Reviewer Role

Purpose: Use AI to review code, designs, and documentation for consistency, style, and potential issues before human review.

1. Submit the output from the Author role (or any code/design you've written) to the AI with a prompt such as: "Review this code for memory leaks, race conditions, and adherence to our coding standards (if you know them)." If you don't have a standards doc, ask AI to suggest conventions.
2. Request a detailed report: line-by-line comments, suggestions for simplification, and identification of anti-patterns.
3. Triangulate the AI's feedback with your own expertise. Remember that AI can miss context-specific issues, so always use human judgment for critical parts.
4. Apply the accepted suggestions or discard them. This step helps you maintain quality across hundreds of repositories without relying solely on peer reviews, which are time-consuming.

Conclusion and Tips

Using AI as a thinking partner transforms how engineering leaders manage cognitive load. By cycling through the five roles—Archaeologist, Experimenter, Critic, Author, and Reviewer—you systematically offload mental work, accelerate decision-making, and maintain high standards. The key is to treat AI as a collaborator, not a replacement: you retain strategic control while the AI handles the grunt work of analysis and generation.

Tips for Success:

• Start small: Apply these roles to a single, manageable subsystem before scaling to your entire 400-repo environment.
• Combine roles: You don't have to run each role independently. Often, the output of the Archaeologist can be fed directly into the Experimenter, creating a smooth pipeline.
• Iterate on prompts: The quality of AI output depends heavily on your input. Invest time in refining how you describe context and desired outcomes.
• Maintain human oversight: AI hallucinates and can miss nuanced business logic. Always verify critical decisions with domain experts.
• Document your AI partnership: Keep logs of prompts and AI responses for future reference and to share with your team—this creates reusable knowledge.

Embrace AI as a thinking partner, and you'll free up mental bandwidth for the creative and strategic challenges that truly benefit from human ingenuity.