Learning in the Age of AI: Curiosity, Feedback Loops, and Owning Your Growth

Early in my career, I moved from France to San Francisco for a job at Yahoo. I had just signed a lease, unpackaged my life, and was thrilled to start. A few weeks later, my entire team's function was unexpectedly outsourced overseas.

Finding yourself in that situation in a new country is surreal: uncertainty about your visa, anxiety about your career path, and the sudden loss of your project. Facing that disruption is daunting, but letting external circumstances define your trajectory is ultimately a choice.

Taking control meant recognizing that I owned my destiny. I treated that crisis as a learning opportunity: reaching out to engineering leads across other teams, learning new internal frameworks on the fly, and expanding my technical network. I also spent time interviewing, using each conversation to reflect on where my gaps lay and what I could do better. That iterative loop of trial, feedback, and adjustment eventually led to a role at YouTube.

Taking control meant recognizing that I owned my destiny. I treated that crisis as a learning opportunity.

That challenging period built far more resilience and engineering intuition than a smooth path ever could. It proved that while technical skills matter, adaptability and ownership sustain a career over the long game. True learning, after all, is experiential. Whether we are navigating an unexpected career pivot, mastering the timing of a multi-stage culinary reduction like craft ramen, or finding our way through unfamiliar cultures while traveling, we build mental models by engaging directly with ambiguity.

The rapid rise of AI is pushing software engineering into a similar pivot today. Automated tools are shifting the ground beneath our feet, altering daily workflows, and redefining what it means to build software.

When I published my previous article on navigating AI change, I was not expecting the volume of messages and follow-up questions that flooded my inbox. One question came up repeatedly: How do we actually learn and grow in the age of AI?

Delegating implementation to AI tools changes how we acquire knowledge. As autonomous agents generate more initial pull requests, our touchpoint shifts from manual typing toward reviewing output, setting boundaries, and auditing system behavior. In this environment, curiosity is the primary engine that keeps our technical judgment sharp. Automated speed is valuable, but merging code without understanding the logic trades long-term intuition for short-term output.

Curiosity as the Primary Engine

Probing code during review is just as essential today as when every line was written by a human. That curiosity aligns directly with our long-standing delivery philosophy: "Think Big, Ship Small." Breaking requirements into small, verifiable iterations guarantees that autonomous models stay within architectural guardrails. It is easy for an agent to get off track when instructions are vague, and we should avoid asking a tool to refactor an entire service domain in an unmonitored attempt.

In practice, interrogating an agent's work relies on turning code reviews into active learning conversations by:

• Interrogating choices: asking "Why did you choose this state management hook over a simpler prop here?" or "Why choose a worker queue over a batch transaction?" when an agent introduces unexpected complexity.
• Exploring alternative patterns: asking "What trade-offs were evaluated before settling on this approach?" to test whether a simpler, more maintainable option exists.
• Evaluating failure modes: asking "How does this layout change affect Interaction to Next Paint (INP) or accessibility (a11y) standards?" to verify system quality.

Consider a code review: an AI agent generates a pull request refactoring a UI component or a database call. Asking the agent to explain execution trade-offs forces a clear breakdown of design rationale. Following up by using the model as a tutor to explain unfamiliar concepts transforms a routine code review into an interactive lesson.

That same curiosity needs to flow in the opposite direction, too: especially when an AI tool reviews code that we wrote. Taking agent feedback at face value misses a prime learning opportunity. When an automated review tool flags code or suggests a refactor, probing the model for context reveals whether guidance stems from a core architectural principle or a team convention.

If an automated review agent recommends splitting a class into smaller modules, asking where that guidance originated or what maintainability metric is improved helps evaluate the suggestion. Distinguishing between deep design requirements and basic syntactic consistency prevents looking for complex answers where simple conventions apply. Formatting rules require straightforward consistency, whereas service boundary decisions require architectural debate.

Harnessing Grounded AI Tools

Beyond code reviews, learning in an AI-accelerated environment goes far beyond inline editor suggestions. Over the past year, a new generation of specialized tools has emerged that transforms how we digest, synthesize, and interrogate complex technical material.

One tool that has fundamentally changed my research workflow is Google NotebookLM. Grounding an AI model directly in your chosen source materials allows you to digest technical specifications, architecture whitepapers, or unfamiliar API documentation interactively.

Uploading technical documents into a grounded environment creates a personalized study partner by:

• Synthesizing complex whitepapers: generating clear overviews of unfamiliar algorithms or consensus protocols.
• Creating interactive audio summaries: generating conversational breakdowns of dense specifications to listen to during a commute.
• Interrogating source materials directly: asking targeted queries like "What are the primary trade-offs between memory overhead and query latency in section three?" to extract specific insights.

Using specialized tools allows us to build mental models significantly faster. Instead of passively reading static text, you actively engage with material through Q&A and audio summaries. Combining grounded tools like NotebookLM with code-centric pair programmers accelerates comprehension while keeping accuracy grounded in original sources.

Involving Subject Matter Experts for Institutional Memory

Even as specialized AI tools accelerate research, there is a critical boundary they cannot cross on their own. While modern AI models index large codebases remarkably well, they suffer from a fundamental limitation: they lack institutional memory. An LLM can scan every repository in an organization and map out dependencies within seconds, but it cannot tell you why a legacy service was designed with specific constraints three years ago, what outage led to a particular workaround, or how historical business decisions shaped current database schemas.

Subject matter experts hold institutional knowledge. Engineers who have operated systems over years possess context no codebase index can capture. Engaging directly with domain experts and reading historical design documents builds both technical understanding and long-term trust across an organization.

Beyond the immediate technical context, these human connections form a durable professional network that outlasts any single project or codebase. Building strong relationships across different domains ensures we have trusted sounding boards when navigating architectural challenges or career transitions.

Involving subject matter experts early in project lifecycles provides insights that automated tools consistently miss, such as:

• Uncovering historical rationale: learning the business trade-offs and operational constraints that shaped current system boundaries.
• Observing problem decomposition: studying how experienced engineering leads structure complex migrations and evaluate risk.
• Building cross-team alignment: establishing strong working relationships and trust across domain owners.

Imagine migrating a legacy user authentication service to a modern multi-location permission model. An AI agent scanning the codebase will see existing database tables, constraints, and current API routes. What the agent cannot see is that two years ago, a temporary schema patch was introduced to support an enterprise customer integration, creating an unwritten edge case in session validation. Sitting down with the domain expert who designed that original authentication layer reveals why that patch exists and how the edge case manifests during traffic spikes.

These human relationships create a compounding feedback loop for automated workflows. AI agents excel at pattern matching and syntax generation, but struggle when faced with undocumented domain edge cases (a limitation highlighted by GitClear's longitudinal research on declining AI code quality). When an agent gets stuck or generates an invalid approach for a complex service, the institutional context we gathered from subject matter experts allows us to prompt the agent effectively and unblock the system.

Human domain experts do not become obsolete in an AI-augmented environment. Their value increases because their context becomes the highest-value input that keeps autonomous tools aligned with real-world requirements. Investing time in building rapport with experienced teammates guarantees that we bring the right context to the table when orchestrating AI workflows.

Diversifying Experiences to Reframe Intuition

While learning at work is essential, another realization has become clear to me over time: technical intuition expands fastest when you step outside your daily routine. This kind of cross-training draws on what educators call the diffuse mode of thinking, allowing the subconscious mind to synthesize complex problems while engaged in unrelated tasks. Diversifying your experiences across different domains prevents mental stagnation and sharpens how you approach complex systems.

Stepping outside your primary stack to build a low-stakes side application for a friend (such as an inventory manager or event organizer) forces you back into the mindset of a beginner. You must navigate product decisions, deployment, and practical UX without corporate infrastructure safety nets, reinforcing product empathy and delivery discipline.

Stepping outside your primary stack to build a low-stakes side application forces you back into the mindset of a beginner.

The same benefit applies to creative challenges outside technology. Mastering multi-stage culinary techniques like craft ramen or French gastronomy requires timing, temperature control, and multi-component assembly that mirror distributed pipeline design. Similarly, practicing macro photography or navigating unfamiliar cultures through travel trains your eye for detail and sharpens your comfort with ambiguity.

Challenging yourself in non-engineering domains builds the exact mental muscle needed when debugging production systems or auditing AI output, and it keeps your attention to detail sharp. Diversifying your experiences reminds us that curiosity is a holistic trait: the more varied your experiences, the richer your perspective as a builder.

Cultivating Real-World Feedback Loops

When evaluating all these avenues for growth, it becomes obvious that we cannot learn everything at once. Software engineering encompasses an immense landscape of tools and paradigms, and trying to master every emerging technology simultaneously leads directly to burnout. Similarly, the constant cognitive demand of auditing machine-generated output can quickly lead to severe fatigue and quiet exhaustion (challenges explored in recent research on how AI usage drains mental resources). Staying effective requires pragmatism about where we spend our energy today and what we consciously defer until later.

Setting intentional direction starts with self-reflection: asking What role do I want to step into next? (a theme we explored when discussing how to become an organizational leader) or What upskilling matters most for my current responsibilities? But relying solely on self-reflection is incomplete without external data points.

In a strong engineering culture, gathering a 360-degree view of your impact combines direct conversations with subtle micro-signals, including:

In a strong engineering culture, gathering a 360-degree view of your impact combines direct conversations with subtle micro-signals.

• Engaging leadership: discussing technical strategy and career progression during regular 1:1s.
• Partnering with peers: asking product managers and teammates where delivery friction occurs during execution.
• Gathering informal micro-signals: observing where recurring project friction happens, tracking which pull request reviews generate pushback, or asking low-stakes, specific questions during casual check-ins.

In addition to interpersonal feedback, we can also use AI tools to audit our own past pull requests, commit histories, and documentation. While we must watch out for automation bias (specifically avoiding using AI to audit AI-generated code), asking an interactive model to evaluate our own human-authored artifacts for clarity or missing edge cases provides an objective baseline for personal growth.

AI tools like NotebookLM or interactive pair programmers can then synthesize these observations. Prompting the model interactively turns the AI into a facilitator that interviews you with targeted questions, one at a time, to draft a realistic 90-day learning plan. But this draft is only a starting point: true alignment requires sitting down with your manager to reconcile the plan with organizational priorities and delivery goals.

Taking Control of Your Own Growth

Ultimately, whether you are building side projects, probing AI agents, or gathering feedback from peers, true personal growth requires a willingness to step into unfamiliar territory. Whether we intentionally seek out hard challenges or unexpected external events force a sudden change upon us, navigating uncertainty is where real capability is forged.

The industry context is changing, but the fundamental principle remains unchanged: stay curious, embrace the unknown, and take full control of your own growth. Learn to be fearless, and own your path.

Thanks to Roxane Nadeau and Michael James Toland for pre-read and feedback.