I was part of the inaugural intern group at OpenAI. Here’s what I learned about becoming an engineer native to AI.

      TL;DR: AI is making it increasingly simple to create software that impresses in demonstrations. However, after my experience in OpenAI’s inaugural intern cohort, I realized the true challenge lies not just in speed but in judgment: knowing what to trust, what to test, and when human input is necessary.

      AI is facilitating the creation of visually impressive software like never before. Prototypes can be developed more quickly. Codebases can be navigated more efficiently. Tests can be generated in less time. Complex documents can be efficiently summarized. This represents a significant breakthrough for engineers.

      Yet, speed does not equate to good judgment. That was a key takeaway from my time at OpenAI. Being part of the first intern cohort reshaped my perspective on software engineering in the age of AI.

      Initially, I focused on improving my programming skills. However, my experience led me to prioritize becoming a better system evaluator: understanding what works, what doesn’t, what merely appears correct, and what can genuinely be trusted.

      My journey into AI was not a straight line. I did not start with a clear career plan. Born in Cairo and moving to Canada at age 10, I initially considered a career in medicine or forensic science. My interest in computer science grew when I realized that software was becoming a highly impactful way to create products, solve problems, and engage with the future of technology.

      Once I made that shift, I sought environments that would accelerate my learning. My first software internship was unpaid and not with a renowned tech company or a well-established AI lab; it was with an early software project led by a senior at Waterloo. Unable to secure a paid software position initially, I seized the opportunity and aimed to leverage it into future roles.

      This path eventually led me to Whatnot, then Verkada, and ultimately OpenAI. When I applied to OpenAI on the day applications opened, I found the process surprising. I expected an emphasis on artificial intelligence during interviews, yet the focus was predominantly on core software engineering skills: algorithms, system design, speed, clarity, and judgment.

      The criteria went beyond merely solving problems; they assessed my ability to think clearly, communicate effectively, and perform under pressure. This expectation matched the culture I encountered at OpenAI, where the pace was quicker than I anticipated for a large tech company. I wrote code on my first day without an extensive onboarding process, which required me to learn quickly, ask insightful questions, and take ownership of my contributions.

      The lesson was clear: speed is important, but sound judgment is even more crucial.

      Being AI-native does not equate to being AI-dependent. I now use AI coding tools regularly. Earlier in my career, I harbored doubts about their utility for serious engineering tasks, but that perception shifted once these tools proved capable of handling actual work: producing code, generating tests, understanding new systems, summarizing information, and alleviating tedious tasks.

      As these tools advance, the significance of fundamental skills increases. A solid understanding of the system being developed allows AI to expedite progress. Without that knowledge, AI can create a false sense of advancement, producing code that seems correct, providing confident explanations, or addressing a specific issue while missing the broader context.

      Thus, the next generation of engineers should strive to be AI-native, not AI-dependent. An AI-native engineer does not accept model outputs blindly; rather, they skillfully employ AI tools, discerning when to trust, question, test, or slow down.

      The role of the engineer evolves rather than disappears. It increasingly centers on asking better questions, designing superior tests, comprehending system architecture, identifying subtle flaws, and knowing when a system is sufficiently reliable for use.

      As AI progresses from chatbots to agents, the stakes are raised. While chatbots respond to inquiries, agents can take actions, operating tools, navigating software, retrieving information, writing code, reviewing documents, and completing tasks. Their enhanced capabilities, however, also introduce greater risks—an incorrect response from a chatbot is problematic, but an agent's misstep can lead to far more serious consequences.

      Thus, the future of AI engineering must encompass not only enhancing model capabilities but also fostering trust. Engineers must consider evaluation, testing, transparency, oversight, and scenarios where human intervention is necessary. They should understand not just whether an AI system can perform a task once but whether it can consistently do so across complex real-world scenarios.

      While demos can be captivating, engineering judgment becomes critical in developing systems that work under unpredictable conditions, incomplete data, shifting user requirements, or unexpected environmental changes.

      A common mistake is conflating demos with actual systems. Demos showcase possibilities, whereas systems must withstand real-world probabilities. Actual users do not follow a perfect flow; workflows often involve missing data, edge cases, ambiguous instructions, outdated systems, conflicting objectives, and unforeseen limitations. The model represents just one component of the equation. The overall system—interface, evaluation loop, tool accessibility, error management, escalation