Over the past year, I have had many 1:1 conversations with engineers and peers across our organization. In almost every conversation, the topic of AI comes up.
These concerns are real. While some engineers are genuinely excited about the speed boost, others feel an understandable sense of anxiety: wondering what these autonomous tools mean for the craft of software engineering, how their day-to-day work will change, and where their individual value lies in an increasingly automated environment. On top of that, there is real adaptation fatigue. The sheer pace of change across the industry can feel relentless, leaving developers exhausted as they continuously re-learn tools, frameworks, and workflows just to stay afloat.
As the lead driving our agentic SDLC at Genius AI, my primary focus is helping our team build trust with these tools. Technology shifts fast, but navigating change effectively always starts with people. Here is how I approach AI, how it has transformed my own workflow, and how we can navigate this space together.
Software Has Always Changed
Historically, software engineering has been defined by constant evolution. The tools and abstractions that feel essential to our work today were nonexistent when many of us started. For instance: React was not around 15 years ago, yet today it is the foundation for web applications everywhere. GraphQL followed a similar path, starting as a small internal experiment before becoming a familiar industry standard.
Feeling uncertain during a major technical shift is completely natural. Every new wave raises the abstraction layer, forcing us to step outside our comfort zone and rethink how we build. Throughout my career, every meaningful leap forward required pushing past the discomfort of the unknown. The key is not mastering every tool overnight: it is staying curious and adapting as the stack evolves. Engineers who embrace new abstractions early build far more leverage over time.
Redefining Our Value: From Implementation to Delegation
When I talk through these changes in 1:1s, I often frame AI not as a replacement for human engineering, but as a powerful new tool in our daily toolkit. AI helps us move faster, but more importantly, it gives us an opportunity to relearn how we structure our daily work.
Our role as individual contributors is shifting in a meaningful way. Hands-on coding remains an essential foundation, not because we need to type every character manually, but because first-hand building experience builds the intuition required to be an effective reviewer. After all, can you truly evaluate systems or audit generated output if you have never wrestled with building them yourself? It might be possible, but it is substantially harder. With that experience under our belt, our highest value is increasingly moving toward upfront planning, architectural design, setting boundaries, and reviewing code with a sharp, critical eye.
In other words: translating logic into syntax is essentially becoming a downstream step; our true craft lies in the architectural vision and the plan. When working alongside intelligent tools, our daily rhythm shifts from manual building to thoughtful delegation and orchestration.
This transition is a fantastic opportunity for engineers to level up much earlier in their careers:
- Delegation: learning how to break a large feature down into clear, well-scoped tasks with explicit acceptance criteria.
- Leverage: relying on automated tools to handle routine boilerplate while keeping human energy focused on subtle edge cases and domain logic.
- Review & Verification: sharpening our technical judgment to audit generated code for correctness, security, and maintainability.
This shift also transforms how we mentor each other. For junior engineers, AI pair programming creates a judgment-free space to ask questions, explore new paradigms, and unblock themselves quickly. For senior engineers, mentorship shifts from reviewing syntax to teaching how to decompose complex problems and audit generated outputs. As teams share custom prompts, workflows, and agentic skills, we build a compounding library of shared leverage.
At the same time, AI tools do not replace computer science fundamentals. Understanding systems design, data structures, and domain logic is more critical today than ever before: you cannot effectively guide or audit an AI agent if you do not understand the underlying principles yourself.
Our long-standing principle of "Think Big, Ship Small" is our best guide here. By breaking large goals into small, verifiable iterations, we guarantee that autonomous models stay within guardrails. It is easy to get off track when instructions are vague, and we do not want to boil the ocean by asking a tool to solve an entire domain in a single attempt.
Personal Velocity Beyond the Metrics
I have seen a noticeable change in my own daily output over the past year. Integrating AI tools directly into my workflow has given me a level of personal leverage that felt impossible just a few years ago.
To put things into perspective: my GitHub contribution count jumped from 3,400 contributions a year to over 5,000, and my PR numbers have more than doubled. That leverage gave me the breathing room to focus on deeper, architectural problems rather than getting bogged down in boilerplate.
That said, I always emphasize in my 1:1s that metrics are not everything. It is crucial for engineering leads to draw a clear line here: you can ship a massive amount of high-quality code in a few well-scoped PRs, or a lot of bad code spread across dozens of PRs. Organizations need to focus on real outcomes rather than performative outputs, especially since treating code volume as a scoreboard is a race to the bottom that ultimately drains team morale.
The true measure of success is never commit volume or PR counts, but whether that added speed allows us to build cleaner systems, solve persistent technical debt, and deliver real value to the people using our software.
Getting Started: Taking the First Step
Not everyone is using AI tools in their daily workflow today, and that is completely fine. Taking the first step does not require an overhaul of how you work overnight.
If you are looking for a place to start, I recommend focusing on a few accessible tools:
- Google Antigravity (AGY): Google's agentic coding platform designed for deep pair programming and workflow automation;
- OpenAI Codex: reliable code generation integrated directly into modern developer environments;
- Anthropic Claude: exceptional for architectural reasoning, complex refactoring, and code reviews.
The best way to experiment is to pick a pet project you have always wanted to build but never had the time for: a small CLI utility, a personal dashboard, or a fun side app. The goal here is not to produce a flawless, production-ready system on your first try. It is meant to be a low-stakes sandbox where you can build trust with the technology.
As you get comfortable, your learning follows a natural progression: you start by familiarizing yourself with basic AI prompting. As you learn more, you begin building reusable skills, assembling automated workflows, constructing agentic harnesses, and eventually designing continuous execution loops.
Of course, experimenting with AI requires responsibility around data privacy, security, and provider terms. Subscriptions can be cancelled at any time if a provider suspects malicious activity or abuse. Make sure to keep sensitive keys and personal data out of prompts, and verify license compliance before incorporating generated code into production systems. A simple rule of thumb applies: do not ask an AI tool to do something you would not do yourself.
Building Confidence with Open Models
For engineers who feel anxious about relying entirely on proprietary cloud services, hands-on experimentation with open models is often the best way to regain a sense of control. Open-weight models have come a long way, and the open-source ecosystem has matured to the point where running capable tools locally on standard hardware is straightforward.
If someone wants to get comfortable with AI tooling on their own terms, a simple local setup is a great way to start:
- Hugging Face: provides a central repository for discovering and downloading fine-tuned open-weight models.
- Gemma Models: Google's open models deliver impressive performance at sizes small enough to run smoothly on personal laptops.
- Qwen Models: Alibaba's open model family offers strong coding capabilities for local experimentation.
- MLX / oMLX: provides fast, hardware-optimized inference designed specifically for workstation chips.
Combining these tools lets you experiment locally without latency, subscription costs, or privacy concerns. For instance: running a compact Gemma model through oMLX makes it easy to build custom helper scripts, experiment with local code indexing, or automate repetitive tasks right on your own machine.
It is also important to keep hardware expectations realistic. Open-source models like Qwen provide strong results, but running them on local workstations requires substantial memory and feels noticeably slower than cloud APIs.
What I Am Excited About
Navigating change is an ongoing journey, but looking down the road, I am genuinely optimistic about where we are heading. I think we are still in the early chapters of learning how engineers and AI tools work together best, and the long game is about giving engineers higher leverage to focus on creative, high-impact problem solving.
As open models improve and context windows expand, these tools will continue to chip away at routine maintenance, debugging test failures, and tedious framework upgrades. Tech has always evolved, and AI is simply the next abstraction layer: one that gives us the leverage to adapt, support each other, and build great software together. If there is one lesson I have learned through every wave of technical change, it is simple: be fearless.