Why senior developers must evolve their AI workflow
AI is changing how software gets written, but many experienced developers are still trying to use it inside workflows designed for a pre-AI world. The result is frustration, endless babysitting of models, and a feeling that "this stuff just doesn’t work." It’s not that AI can’t help you write great software—it’s that your workflow may not be built for it.
This article breaks down why traditional best practices can hold you back, and how to evolve your workflow so AI becomes a force multiplier instead of a burden.
Stop optimizing for the wrong constraints
Most senior engineers were trained in an environment where implementation was expensive. You optimized for:
• Carefully planned abstractions
• Heavy up-front design
• Maximum code reuse
• Minimizing rework at all costs
In an AI-first world, the economics have shifted. Generating, refactoring, and even throwing away code is dramatically cheaper. That doesn’t mean code quality no longer matters—but it does mean you shouldn’t blindly optimize for yesterday’s constraints.
Token usage is a tool problem, not your north star
A common objection to AI-heavy workflows is that poor code reuse or messy structure will explode token usage and costs. That’s really a limitation of the specific model or tool setup you’re using—not an immutable law of development.
If you’re constantly worrying about context windows and token counts, you’re optimizing for the economics of your vendor, not your own productivity. Instead of shaping your entire workflow around token frugality, treat it as a tooling challenge: choose better tools, or add specialized models and utilities where needed.
Learn your AI tools like you learned your language and framework
Not all models and tools are created equal. Some are general-purpose, some are tuned for coding, some are great at retrieval, and some are built as agents that can operate on your codebase with little babysitting.
Invest real time in understanding:
• What each model is good and bad at
• How it handles long context or large projects
• How to integrate open-weight models or local tools alongside cloud APIs
• Where agents or workflow tools can replace manual prompting
For example, if you’re already exploring AI-powered workflows, you might also benefit from seeing how others automate complex tasks, like the way AI agents can automate an entire e‑commerce workflow. The point isn’t to copy that exact setup, but to see what’s possible when you lean into the tools instead of fighting them.
Stop manually maintaining context
One of the most common failure modes is treating AI like a brilliant junior dev with amnesia. You keep re-explaining:
• Your architecture
• Project structure
• Design decisions
• Prior conversations and constraints
That’s exhausting—and a sign your workflow is wrong.
Instead of being the human memory layer for your AI, offload context management to tools or code:
• Use project-aware AI tools that index your repository and provide relevant files automatically.
• Add retrieval or embedding-based search so the AI can pull what it needs on demand.
• Write small scripts or “skills” that expose focused, useful slices of information (e.g., a script that outputs your routing table, or a summary of your domain models).
The goal is smaller, targeted context windows tailored to the task, not dumping your entire project into every conversation.
Write your own AI skills and scripts
One of the most powerful mindset shifts is to stop thinking of AI as a single chat box and start thinking in terms of capabilities. You can script those capabilities yourself.
Examples of custom skills or scripts you might add:
• A command that prints a high-level architecture summary
• A script that lists all modules and their responsibilities
• A tool that generates a concise spec from your issue tracker
• A script that extracts all API endpoints and their parameters
These skills can then be wired into your AI tools or agents, giving them reliable, structured context on demand. You’re no longer retyping explanations—you’re exposing your system in a machine-friendly way.
Embrace experimentation instead of perfection
Many senior developers approach AI as if every interaction must produce production-ready code. That’s a recipe for disappointment.
A better mindset is to treat AI as a rapid experimentation engine:
• Generate three alternative implementations and compare them.
• Prototype a risky idea in minutes, then throw it away.
• Ask for several different API designs or UX flows before committing.
In the past, experimentation was expensive—time, attention, and opportunity cost. With AI, it’s cheap. If you’re not using it to explore options you wouldn’t have built yourself, you’re leaving a lot of value on the table.
Not every session needs to end with shippable code. Sometimes the goal is simply to learn, explore trade-offs, or sharpen your own thinking.
Relearn how to use rejection as feedback
Older generations of developers grew up dealing with cryptic compiler errors and vague stack traces. You learned through rejection: something broke, you dug in, you adapted.
AI brings a different kind of rejection: bad suggestions, hallucinated APIs, or awkward designs. It’s easy to read that as "AI is useless" rather than "my prompt, tool choice, or workflow needs adjusting."
Instead of giving up after a few bad outputs:
• Treat poor results as signal about your instructions or the tool.
• Iterate on prompts, context, or the skill scripts you expose.
• Use side-by-side comparisons of different prompts or models to see what actually works better.
Use your senior judgment where it matters most
AI dramatically lowers the cost of implementation. That makes your judgment about what to implement more valuable, not less.
Your edge as a senior engineer is not typing speed or memorizing APIs. It’s your ability to recognize:
• Bad product ideas or confusing UX
• Architectural choices that won’t scale
• Solutions that create more problems than they solve
• Hidden complexity and long-term maintenance risks
Let AI handle more of the mechanical implementation, but don’t outsource your taste, intuition, or product sense. The cheaper it is to build something, the more dangerous it is to build the wrong thing.
Separate lasting principles from historical constraints
Best practices aren’t sacred—they’re responses to specific constraints. Many of the habits senior engineers carry today were created for a world where:
• Writing and refactoring code was slow and manual.
• Tooling was weak and static analysis was limited.
• Collaboration and automation were harder.
Those constraints are changing. That doesn’t mean everything you’ve learned is obsolete, but it does mean you should regularly ask:
• Is this practice still solving a real constraint I have today?
• Or is it a workaround for a problem AI and modern tooling already solved?
Your experience is still incredibly valuable—but only if you’re willing to re-evaluate which parts still serve you and which parts need to be relearned in an AI-native context.
Build AI into your broader workflow, not just coding
AI isn’t only for writing code. It can help you manage the surrounding work that makes you effective as a senior engineer:
• Drafting design docs and RFCs
• Summarizing long threads or specs
• Generating test plans or edge-case checklists
• Turning meeting notes into concrete tasks
If you’re already using AI for development, it’s worth exploring how it can support adjacent workflows too—similar to how people are reshaping creative and productivity pipelines in areas like AI video editing workflows that actually work in practice.
Adopt an experimental mindset, not a new dogma
The goal isn’t to replace one rigid set of best practices with another. There is no single "correct" AI workflow yet—and that’s a good thing. We’re still collectively figuring it out.
Instead of waiting for a perfect playbook or a definitive course, treat this moment as an invitation to experiment:
• Try different tools and models.
• Automate small pieces of context management.
• Use AI to explore ideas you’d normally discard as too time-consuming.
• Continuously refine where you, as a senior engineer, add the most value.
The biggest mistake an experienced developer can make right now is assuming that years of traditional experience automatically translate into AI-native mastery. They don’t—and that’s what makes this shift exciting. The developers who are willing to rethink their workflows, question old constraints, and build new habits around AI will be the ones who thrive.
Comments
No comments yet. Be the first to share your thoughts!