Here’s a question I can’t figure out: Am I a software engineer who codes, or a system designer who directs AI?

Because the job market doesn’t seem to know either.

The Interview That Changed Everything

I had a pretty standard first-round interview with a startup recently. We talked about the company, the role, and my experience — it was a good conversation. Then, at the end, the recruiter surprised me with a coding challenge.

I was honest with him.

“Look, if I’d known there was a coding portion, I would have brushed up, but I haven’t written code since November. AI does all my coding now.”

He wasn’t ready for that answer. Honestly, neither was I.

But it made me realize something important. As a job seeker in 2026, I don’t know what I’m supposed to be preparing for—and I think a lot of us are in that same boat.

Subscribe now

The Mismatch Nobody’s Talking About

The role is changing faster than the interview process.

Companies are still testing for algorithm skills, whiteboard coding, and LeetCode-style problems. But in my actual job? I haven’t touched a keyboard to write code in months.

AI writes the code. I design the system. I articulate the features. I review the output.

There’s a fundamental mismatch between what companies test for and what the job actually requires now. And that mismatch has forced me to ask a harder question:

What are the skills that actually matter?

What the Right Interviews Look Like

In the interviews I’ve had recently, the ones that felt right weren’t coding tests. They were:

• System design conversations

• Architecture pattern discussions

• How you structure an application

• How do you guide an AI agent to build the right thing

Coding knowledge is still relevant—but not for writing code. It’s for reviewing it. For directing it.

Why AI Can’t See the Forest

Here’s what I’ve learned working with AI every day:

AI can’t see the forest. It’s incredible at implementing the feature—it sees the trees—but it doesn’t know the existing patterns in your application. It doesn’t understand the architecture.

You can tell it. I do that in Claude every day. But it’s my job to hold that vision.

That’s the gap. That’s the new engineering role.

The human’s job is to:

1. Communicate the architecture clearly

2. Guide the agents toward the right pattern

3. Make sure the pieces fit together

AI writes the code. I make sure it’s the right code.

The Role That’s Emerging

So when I think about what I’m preparing for now, I’m not preparing for coding tests anymore.

I’m focusing on:

• System design and how to think about complex applications

• Architecture patterns and when to apply them

• Clear articulation—how to describe what I want precisely enough that an agent can build it

If a company wants me to grind LeetCode-style problems and whiteboard algorithms, we’re not aligned on what the role is.

Because the role I’m preparing for—the role I think is emerging—isn’t “engineer who codes.”

That role is gone. That role was five years ago.

The new role is an engineer who designs systems and directs AI to build them.

What This Means for You

If you’re a job seeker right now, you’re caught in the same transition I am.

The market hasn’t caught up yet. Some companies still test for the old skills, but the actual work is shifting—and fast.

Don’t feel bad if you haven’t been coding. That’s not the skill gap.

Instead, focus on:

• System design fundamentals

• Architecture and how applications fit together

• Communication skills for working with AI agents

The role is changing. Make sure you’re prepared for the role that’s coming, not the one that’s disappearing.

My New Approach

I don’t know if I failed that interview or if that interview failed to test for the right thing.

But I know this: I’m not grinding LeetCode anymore.

It just doesn’t make sense. It feels like a waste of my time. Instead, I’m building the skills for the role I actually want.

Have you been in an interview recently that felt misaligned with the actual work you do? I’m curious if I’m the only one feeling this shift.

If this resonated, I’ve got more content on AI engineering and how the space is evolving. Subscribe to my newsletter so you don’t miss what’s coming next.

AI built a feature in 47 minutes, which would have taken me 8 hours of work a few years ago. But here’s what nobody tells you: without the right strategies, that same AI will waste three hours building the wrong thing.

Hi, I’m Chuck, and I’ve been writing code for 30 years. In 2023, I realized I had to either embrace AI or find a new career. I chose to embrace it. Since then, I’ve built a dozen applications using coding agents, and today I’m sharing every strategy learned with you.

AI changes everything, most notably, it speeds everything up. What took a day now takes an hour.

The speed means a few things:

First, your feedback cycle is much faster, errors and wrong directions surface faster, and getting to success surfaces faster.

Second, a lot of code is now throwaway. It’s cost-effective primarily to write and discard rather than to write and refactor.

Third, software development potholes that took years to run into now surface in weeks or months.

Fourth, without guidance, AI quickly goes off the rails and over the cliff.

In my time using coding agents like Cursor, I’ve discovered 12 strategies that help keep AI from going over the cliff. These were learned the hard way, by trial and error.

1. Use the Agent.md

One of the many things I noticed about LLMs is that they all want to add “fallbacks.”

Fallbacks are conditional code that executes when the first condition fails. This is great when your code is going to Mars, but most code isn’t going to Mars, certainly not mine. To make matters worse, Fallbacks are inherently buggy and aren’t needed most of the time.

This is where an Agent.md file comes in. You can instruct the LLM not to use fallbacks. In fact, you can tell it to do anything. Anything you would add to a prompt can be added to the Agent.md. The file is automatically added to each new context.

At the moment, each coding agent has their own agent.md file. Cursor calls their’s .cursorrules, Claude Code calls their’s claude.md. I suspect that in the near future, coding agents will standardize on a common name.

In my Agent.md, I define the software patterns, the testing strategy, and the architecture I want to use. Anything I find the agent doing repeatedly due to a lack of context or direction, I add to the file.

Here’s a link to a repository of agent rules.

Once your Agent.md file is set up, you’ll want to use AI unhindered.

2. Going Full Throttle

Both Claude Code and Cursor AI start in a “safe mode” out of the box. Safe mode requires permission for each tool call. After a few minutes of approving EVERY tool call, I was done with safe mode.

Fortunately, each Coding Agent allows you to opt out of “safe mode”. The risk is that AI can go off and do undesirable things, but in the time I’ve used coding agents, I’ve never had it do anything irreversible.

I do keep an eye on what the LLM is doing, but I don’t feel comfortable walking away from the Coding Agent just yet.

Honestly, unless you’re asking the LLM to work on live production code, and I don’t know why you’d want safe mode.

Now that you’ve freed your coding agent, we need to define the problem.

3. Defining your problem

AI is a literalist. You get what you ask for, which means vague prompts produce vague results.

I’ve found that providing AI with detailed requirements and asking for an “assessment” gets the best results. This allows AI to look for gaps in the design and respond with follow-up questions. After a couple of back-and-forths, you’ll have a solid plan.

In recent releases, both Cursor and Claude Code have added “Plan Mode,” which formalizes the above process.

I take it a step further and have another LLM review the plan. For example, I use ChatGPT for the first AI assessment. It generates a markdown doc with all the requirements. I then give that document to Claude for feedback, and Claude’s second review always finds missed gaps.

This is a taste thing, but AI tends to over-architect for me. Again, AI seems to think the code is on its way to Mars.

Once you’ve settled on a plan, ask AI to save it to a document in your project.

Which brings me to the next point.

4. Create a Phased Plan

After you’ve created a plan, ask AI to break the work up into phases. You want small units of work; the smaller the better. The smaller the unit, the higher the chance of success.

Some coding agents do this out of the box, but if they don’t, ask them to.

The best plan will still fail if you can’t track progress. This is where checklists come in.

5. Ask for a Checklist

Ask AI for a checklist and tell it you need one to track progress. Many of the coding agents have added the checklist to the agent prompt and ui, but sometimes I still need a checklist to track progress or track long-running work.

The checklist also gives AI something to measure itself against, so it knows when it’s done.

Checklists are great, but how do we span contexts with checklists? This is where our handoff document comes in.

6. Create a Handoff Document

What is a handoff document?

A handoff document is a high-level description of the application. Its purpose is to bring an empty context up to speed on your application’s domain, code, and architecture.

Ideally, the agent picks up in stride, where the previous context left off.

In my Agents.MD, I instruct the agent to update my handoff document with high-level changes. What we don’t want is every detail in the document; I need a high-level summary, and I let AI determine what is.

My workflow goes a bit like this:

Each time I started a new context, I included my handoff document and instructed AI on the new feature. AI picks up the task and begins working like it’s been on the project for 6 months.

The handoff document is great for smaller applications, but in larger applications, it consumes too many tokens and isn’t practical. I’m considering other options, such as a vector database or a graph database.

But I’m still experimenting.

I’d love to hear how you’re approaching this problem. Leave a comment below.

Even with checklists and a handoff document, AI makes mistakes. This is where commits come in.

7. Check in Often

Make small commits. Small commits let you revert to a known good state. I’ve found that sometimes AI goes down the rabbit hole, and there is no recovery.

Just reset.

8. Reset the Context

Be ruthless in resetting the context.

Sometimes AI goes down the wrong path or makes a mistake, eject and start over. When all of your documents are in order, it’s a breeze to start a new context. This is the brilliance of the handoff document.

But I’ll be honest, when working with AI – I humanize AI because it feels like I’m working with another human, and hitting that reset button sometimes tugs at my humanity.

One way to limit the rabbit-holes is through testing.

9. Testing

When I was a software engineer, testing sucked. Writing testing code is some of the most mundane work for a software engineer.

With AI, there is no reason you shouldn’t be testing your code. AI will write all the tests for you. In fact, you can specify 80% test coverage in the agent.md, and the coding agent magically adds the tests.

I’ve found testing beneficial; beyond the quality component, it gives AI a structure to validate its work. This leads to higher-quality code and better use of AI.

A word of caution, I often have AI make code changes without updating the tests. After the code is working, I ask AI to update the tests. Sometimes AI takes the tests too seriously and changes production code to match the tests, undoing all the changes we just made.

Another way I’ve found to improve quality is through automation.

10. Automate, Automate, Automate

Make things as easy as possible.

Before AI, I’d often heard: “One-touch deployments, that would be great, but we don’t have the time.” Now there is no excuse, AI will automate everything for you.

My goal is to have every action be a single command. For example:

- If I want to start the application? ./start.sh.

- I want to run the tests. ./test.sh.

- Deploy the application? You guessed it ./deploy.sh

Automation serves two purposes:

- First, it saves you time.

- Second, it removes human error from the process.

Any place there is friction and multiple steps, I want to automate it away. But to solve the more complex problems, I sometimes need more capable LLMs.

11. Use the Best LLM

Don’t skimp on model performance. The latest models are expensive, but in an effort to save money, they might end up costing you.

Occasionally, Cursor recommends using Auto mode to save tokens. Ok, that sounds good, what could go wrong? I’m always open to saving money. So I turned it on and implemented a feature. It turned into a disaster. I spent the next 3 hours unwinding the mess using the latest models, and it cost twice as much as I would have paid if I hadn’t used auto mode. My point isn’t that auto mode is bad; it’s that working on complex problems requires the best models.

But sometimes, even the best models aren’t enough; you need the right tools.

12. Tools

Think of AI as the brain; it thinks, but it can’t do anything. This is the power of a tool. It gives AI the ability to act.

I put coding agent tools into two classes:

First are tools designed to enhance software development. Think of GitHub’s MCP or Anthropic’s Sequential Thinking MCP; these tools generally make coding agents more capable.

Second are tools that interact with the project. For example, a database MCP or a command-line tool. These tools enable coding agents to write code, run it, and test the results, completing a full feedback cycle.

The brilliant thing about AI is that if you need a tool and there isn’t one, AI can create it for you.

Here are the tools I use with Cursor:

The first tool is called Serena. Serena attempts to offload tasks like reading files and saving data to memory that would normally have AI generate commands to execute the operation. The goal of this project is to reduce the number of tokens used and keep common operations local.

The next tool I use is called Sequential Thinking by Anthropic. If it’s by Anthropic, it’s almost guaranteed to be good. What this tool does is break down complex problems into manageable steps. It adds dynamic and reflective problem-solving through a structured thinking process.

The last tool I use is project-specific; it’s called Neo4j MCP, and AI created it. It’s been invaluable in working with Neo4j. Before, AI would ask me to run queries and then paste the results into the chat. This became cumbersome very quickly. With the tool, AI runs its own queries, and no human intervention is needed.

It’s beautiful, and it’s quicker. If you find friction in your development process, ask AI to help; you might be surprised what comes up.

In Closing

Let’s be honest here, working with Coding Agents feels a lot like pairing with a brilliant junior programmer who occasionally forgets everything we just told them. These 12 strategies are how I manage this relationship. And they might not work for everyone, or you, and that’s ok. Find what works for you.

So my question to you is: What’s working for you? Drop a comment below and let me know.

Last week, I watched my three-year-old daughter talk to Siri on her iPad. I wasn’t sure what to think. Should she be talking to AI at such a young age?

A new study from MIT shows that using AI can weaken critical thinking. Here is how I’m preparing my daughter for a world with AI, and why I think AI is like processed food.

The Study

MIT sought to answer the question: “What is the cognitive cost of using AI when writing an essay?”

Fifty-five participants ranging from 18 to 54 years old, with an average age of 23.

The participants were broken up into three groups:

• The Brain Only - no tools

• The Search Engine - access to a search engine

• The LLM Group - access to ChatGPT

Each participant had 20 minutes to write one essay.

How did each group fare? Let's look at the results.

The Results

Both the Brain Only and the Search Engine Group had similar results. However, the LLM Group fared much worse on recall and critical thinking tests.

Why? Because The Brain Only and The Search Engine Groups organically wrote their essays, and had intimate knowledge of the content. Conversely, the LLM Group participants copied and pasted their answers directly from ChatGPT. When asked why, the LLM Group said they felt pressured by the 20-minute time limit.

The results? LLMs weaken critical thinking. In some young adults, critical thinking has never developed. Relying solely on AI for critical thinking left participants gullible and lacking in creativity.

AI is Processed Food for the Brain

After reading the study, I now watch my daughter’s interactions with AI differently. I’m more aware of the conversations and the need to put guardrails on those conversations. I view AI similarly to how I view processed foods; it’s not malicious, but it can still be harmful over time if used incorrectly.

So, how do I prepare my daughter for a world where she’ll be interacting with AI on a daily basis?

Four Strategies

My first reaction was forbidding my daughter access to AI, but that’s not realistic. So instead of banning AI, I need to find a balanced approach. But what does that look like?

I’ve identified four strategies to help my daughter navigate AI.

1. Mastery before Automation

My daughter must learn the skill before automating it.

An insight from the study reveals that understanding the subject and doing the work is key to expanding your knowledge and building critical thinking skills. AI’s instant answer doesn’t serve my daughter. When AI gives instant answers, the “ah ha or “why” is lost. Being told and experiencing it are vastly different, even though they end in the same place.

For example, she’ll need to learn math before using AI to solve math problems. Why? Because when she figures out 7x3, she’ll not only know the answer, but learn patterns that she can apply to other math problems. Using AI robs her of that insight.

This is the same approach that master woodworkers take with their apprentices. Apprentices must first master joinery before they create joints with power tools.

2. AI is Magical, but Fallible

What’s lost in all the AI hype is that AI is often wrong.

For example, AI recently included glue as a key ingredient in pizza when asked for the perfect pizza.

When my daughter has the knowledge, she can recognize when AI is wrong. But she needs the knowledge.

Knowledge layers like sediment settling in a pond – each ‘why’, every book, each moment of curiosity adds another layer. Leaving an accumulated understanding that lets her spot AI’s wrong answers.

3. Hard is OK

‘Hard’ is where growth happens. What the study showed is that those who did ‘hard'work grew in critical thinking skills and memory. Those who did ‘easy’ lost critical thinking skills and couldn’t recall specifics. The study also showed that there is no middle ground. You’re either gaining or losing.

I can’t tell you how many times I’ve heard, “But Daddy, it’s tooo hard! Can you do it for me?” This is when I say, “Yes, it is hard, but that means you’re learning and growing.” To which she replies with, “But Daddy, I don’t want to grow right now.”

We live in an instant culture, and AI is yet another extension of it. Some things just take time - learning is one of those things.

When my daughter struggles with an activity, she becomes frustrated. I guide her in one of two directions:

• Help her overcome her challenge; sometimes, a little nudge in the right direction is all she needs.

• Or “let’s step away for a few minutes” and come back to the activity; this break allows her to collect herself and return to the activity fresh.

While my daughter isn’t quite old enough, another suggestion is using a “struggle jar.” Put hard-earned wins or almost wins in the jar. And celebrate the process of struggling, even if they’re not successful.

4. AI is a Thinking Partner, Not a Replacement

AI is here, and it’s only getting more intertwined with our daily lives. Some might interpret the study’s results as a warning against using AI. That’s a wrong interpretation.

Much like processed foods, there’s a responsible way to use AI. Offloading your thinking to AI is the wrong way.

Think of AI as a study buddy who is sometimes wrong. The best study sessions are collaborative, where you question each other.

While my daughter is only three years old and this conversation is a few years away, I’m already thinking about what to say.

In my interactions with AI, I use a framework called “Think-Check-Create.” This helps me get the best out of AI without offloading my thinking to AI.

THINK First
Create the first draft. Think about the topic, the problem, and the possible solutions. The more you explore your idea, the stronger the foundation you’ll start with.

CHECK with AI
Ask for feedback on your first draft. Ask AI to qualify its answers. Challenge AI on it’s response. If needed, provide additional information for the conversation.

CREATE Something New
Combine what you learned from AI with your knowledge and create something new. Don’t copy AI’s responses, instead internalize them and write them in your voice, this forces you to make them your own.

Here is a simplified version:

Think: “Brain first.”
Check: “AI feedback.”
Create: “Combine in your voice.”

For example:

Think: Write all you know about elephants.
Check: Ask AI for feedback on what you wrote and any facts about elephants you missed.
Create: Combine the feedback from AI to create something new in your own words about elephants.

This makes AI a tool that helps my daughter think and grow, and not an AI crutch that weakens her.

Closing

AI is here.

It’s not whether our children will use AI, it’s a matter of when. The question is: will they use it as a crutch or a tool? The next time my daughter tells me: “It’s too hard Daddy!” I’ll remember that it means she’s learning and the best thing I can do is support her. This might be a small nudge over the finish line or taking a break and going for a walk.

References

• Your Brain on ChatGPT: Accumulation of Cognitive Debt when Using an AI

• Claude used to critique and explore different idea threads

• https://autogenai.com/uk/blog/what-is-an-ai-hallucination/

At some point, most of us will switch jobs. Being unprepared when you leave can make finding your next opportunity much harder, but it doesn't need to be this way. I've found there are three important steps you should take before leaving your company that can save you a truckload of stress in your job search.

After spending multiple decades building software, I've experienced both quitting and being laid off. The advice I'm sharing comes from both my successes and mistakes along the way.

I understand that in some situations, when you're let go, you're asked to leave immediately. However, some companies allow you to wrap up your work and transfer knowledge to other employees. This remaining time is a great opportunity to start working on your stories and updating your resume in preparation for your job search.

Step #1 - Document Your Job Descriptions and Impact

The best time to document your impact and responsibilities is when you have access to the project and its documentation. Trust me, years down the road, you'll appreciate having these details.

I've had many positions over my career, and I can't remember everything I did at every company. I maintain a document I call "Experience Details" that outlines positions I've held. I try to capture:

• My official job responsibilities

• Projects I led or contributed to

• Measurable impacts (cost savings, efficiency improvements, etc.)

• Technologies and methodologies I used

• Challenges I overcame

Don't just write "Improved database performance" – that's worthless. Instead, note specific metrics like response time improvements or reduced server load. These specific metrics will make your resume stand out and give you concrete talking points in interviews.

The purpose of this documentation is to refresh my memory when discussing my successes during interviews and on my resume. It also allows me to revisit my projects and identify responsibilities that weren't apparent at the time.

For example, I worked on a greenfield project where I created everything from the first line of code to setting up the production deployments. At the time, I framed the position as a Senior Software Engineer. But as I moved through my career and started to see myself as a Software Architect, I realized a lot of the work I did on that project was actually defining the software architecture.

I was able to revisit my work, reframe it as a Software Architecture position, and speak to that aspect in subsequent interviews.

Step #2 - Ask Co-workers for References and Recommendations

Identify team members who will give you recommendations and serve as your references. Companies always want to talk to previous co-workers about your performance and what it's like working with you. It's much easier to ask your co-workers while you work with them than reaching out after the fact.

Make sure you have 4 or 5 people willing to give you a good recommendation.

During one of my hiring cycles, I received an offer and provided 3 references. However, when the hiring manager reached out, two references ghosted the hiring manager. And when I reached out they ghosted me also. Luckily, I had two other references who came through, and I landed the position.

Had I only secured those three references, I might have lost the opportunity. The lesson? Prepare for the unexpected — people's circumstances change, and your career shouldn't depend on any single person.

Subscribe now

Step #3 - Say Proper Goodbyes

People often overlook goodbyes, but you shouldn't. You don't know how you might encounter your former co-workers in the future. I've worked with the same co-workers across multiple jobs. Sometimes I'm the boss, and sometimes they are. The more goodwill you can build, the better.

I know some don't want a lot of attention, while others want to celebrate your time at the company with events like a team lunch.

I get it.

I once left a company, and my team took me out to dinner to celebrate my new "freedom." The waiter, seeing our jubilant crowd, asked what we were celebrating. Someone shouted out, "Chuck getting fired!" It was an awkward moment. I understand not wanting to be the center of attention.

My advice on goodbyes: Don't leave people hanging. They will notice you're gone and might be disappointed because they didn't have the opportunity to say goodbye. Give them that opportunity—it provides closure.

It's how I feel when I've found out someone's left without having the opportunity to say goodbye and wish them the best.

When I leave a company, I always say goodbye and offer to connect, usually via LinkedIn.

Bonus Step

Here's a bonus step: This isn't something you do when you're leaving, but rather as you change positions and responsibilities. Update your Experience Document every 6 months. This way, you can speak to your responsibilities on your resume or in your interviews, even if you're escorted out of the building with no warning.

Bringing It All Together

Whether you're leaving on your own terms or facing an unexpected layoff like I did, these three steps—documenting your impact, securing multiple references, and saying proper goodbyes—create a foundation for your next opportunity. The preparation I'm suggesting creates lasting career resilience.

Remember, career transitions happen to most people. It's not the transition itself but how prepared you are that determines what comes next.

Moving Forward

Building a strong professional network and maintaining good documentation of your achievements are ongoing practices that will serve you throughout your career journey.

Remember that preparation is key—the best time to prepare for your next position is while you're still in your current one.

Author: Chuck Conway specializes in software engineering and AI Engineering. Connect with him on social media: X or visit him on YouTube.

Dependency Injection is a main stay in static languages, but does it make sense to use it in Python? Will it make me a better Python programmer?

And, wait, what is dependency injection again?

First, let's answer the question: What is dependency injection (DI)?

Dependency injection is a pattern that, when used, moves the construction of an object outside of the class. Instead, the class takes a dependency on an abstraction.

In static languages like C# and Java, dependency injection is heavily used to reduce coupling and facilitate testing. In fact, you'll find dependency injection frameworks whose sole purpose is to maintain dependencies and their relationships to each other.

Dependency injection serves two main purposes:

First, it reduces complexity by taking a dependency on an abstraction.

Second, depending on an abstraction allows different implementations, including mocks for testing, to be passed into the class or function.

Let me demonstrate with some code:

# Before 
class User:
    def __init__(self):
        self.database = SqlServerDatabase()

    def get_details(self, user_id: int):
        self.database.get_user_details(user_id)

# After  
class User:
    def __init__(self, database: Database):
        self.database = database

    def get_details(self, user_id: int):
        self.database.get_user_details(user_id)

This is dependency injection in its simplest form. While the concept is straightforward, its power lies in enabling flexible designs.

In the Before example, the User class is tightly coupled to the SqlServerDatabase class. If we want to test the `User` class, we need to create a new SqlServerDatabase instance.

In the After example, the User class is loosely coupled to the Database abstraction. We can pass in a different implementation of the Database abstraction to the User class.

Let me demonstrate this flexibility with a practical example that shows how we can switch between different database implementations:

date_string = "2023-10-01"  # Example date string
date_format = "%Y-%m-%d"    # Input string format
birthday = datetime.strptime(date_string, date_format) 
turn_of_the_century = datetime.strptime('2000-01-01', date_format)

database = PostgresDatabase("")

if birthday < turn_of_the_century:
    database = SqlServerDatabase("")

user = User(database=database)
user.get_details(user_id=1)

On line 6 (if birthday < turn_of_the_century:), dependency injection allows us to swap implementations easily based on the different conditions. While this flexibility is valuable for production code, one of the most common uses for dependency injection, especially in static languages, is in testing.

Here's an example:

class UserTests(unittest.TestCase):
    def test_is_authenticated(self):
        database = MockDatabase('connection_string')
        
        is_authenticated = User(database).is_authenticated('user', 'pass')

        self.assertTrue(is_authenticated)

This is a simple example using a MockDatabase class. In Python, we could also use the built-in Mock class to achieve the same outcome.

Interestingly, dependency injection wasn't widely used in the Python projects I've worked on. Coming from a static language background, I was surprised — and it seemed counterintuitive.

However, there's a reason for this limited adoption. Python's built-in patch functionality already provides excellent testing capabilities, eliminating one of dependency injection's main benefits. While Dependency Injection can still help reduce complexity, Python has other approaches to achieve the same goal.

I'm not saying that Dependency Injection shouldn't be used in Python. Quite the contrary, like all tools and patterns, there is a place and time to use them. And Dependency Injection is just another tool in your tool belt that will improve the quality of your code.

I think Dependency Injection would generally increase the code quality in most Python projects.

If you're interested in exploring Dependency Injection further, I recommend checking out two popular Python frameworks:

• Injector (github.com/python-injector/injector)

• Dependency Injector (python-dependency-injector.ets-labs.org)

Subscribe now

As a Software Craftsman with years of experience in the field, I've witnessed the impact of Generative AI on software development since the introduction of ChatGPT in 2023. Through practical application, I've identified five powerful ways to leverage this technology to enhance productivity.

1. Enhanced Code Search

The most frequent way I utilize Generative AI is to search for technical information. Traditional search engines require precise terminology, while Generative AI understands concepts and context. For instance, when searching for the principle of method parameter optimization, I ask:

Prompt

What's the name of the programming concept where you should only pass parameters that are actually used by the method? Passing parameters to a method that aren't used by the method creates unneeded dependencies. 

Generative AI understands the concept I'm describing (Law of Demeter) and provides the correct answer, eliminating the need for multiple searches.

2. Efficient Code Generation

Generative AI excels at automating repetitive coding tasks. Recently, I needed to convert a large JSON file into database insert statements. Instead of writing tedious conversion code, I provided the JSON data to the AI with clear instructions for generating MS SQL Server insert statements. This approach saved hours of manual coding time and reduced the possibility of errors.

Prompt:

Use the JSON data provided below and generate insert statements for MS SQL Server to be inserted into the dbo.Users table.

[  
{  
"Username": "musiclover87",  
"Lastname": "Smith",  
"Firstname": "Alice",  
"Birthdate": "1987-06-12",  
"Password": "password123",  
"FavoriteIceCream": "Chocolate Chip Cookie Dough",  
"FavoriteSuperhero": "Spider-Man"  
},  
{  
"Username": "bookworm92",  
"Lastname": "Johnson",  
"Firstname": "Bob",  
"Birthdate": "1992-03-21",  
"Password": "securePassword",  
"FavoriteIceCream": "Mint Chocolate Chip",  
"FavoriteSuperhero": "Batman"  
},  
{  
"Username": "gamergirl01",  
"Lastname": "Williams",  
"Firstname": "Carol",  
"Birthdate": "2001-11-05",  
"Password": "gamer4life",  
"FavoriteIceCream": "Strawberry",  
"FavoriteSuperhero": "Wonder Woman"  
},  
{  
"Username": "techieguy95",  
"Lastname": "Brown",  
"Firstname": "David",  
"Birthdate": "1995-08-18",  
"Password": "techmaster",  
"FavoriteIceCream": "Vanilla Bean",  
"FavoriteSuperhero": "Iron Man"  
},  
{  
"Username": "foodiequeen89",  
"Lastname": "Davis",  
"Firstname": "Emily",  
"Birthdate": "1989-04-29",  
"Password": "delicious123",  
"FavoriteIceCream": "Salted Caramel",  
"FavoriteSuperhero": "Captain Marvel"  
},  
{  
"Username": "traveler76",  
"Lastname": "Miller",  
"Firstname": "Frank",  
"Birthdate": "1976-12-02",  
"Password": "adventuretime",  
"FavoriteIceCream": "Coffee",  
"FavoriteSuperhero": "Thor"  
},  
{  
"Username": "fitnessfanatic98",  
"Lastname": "Wilson",  
"Firstname": "Grace",  
"Birthdate": "1998-09-15",  
"Password": "strongandfit",  
"FavoriteIceCream": "Mango Sorbet",  
"FavoriteSuperhero": "Black Widow"  
},  
{  
"Username": "photographylover85",  
"Lastname": "Moore",  
"Firstname": "Henry",  
"Birthdate": "1985-05-23",  
"Password": "pictureperfect",  
"FavoriteIceCream": "Pistachio",  
"FavoriteSuperhero": "Superman"  
},  
{  
"Username": "musicjunkie93",  
"Lastname": "Taylor",  
"Firstname": "Isabella",  
"Birthdate": "1993-02-08",  
"Password": "musicislife",  
"FavoriteIceCream": "Rocky Road",  
"FavoriteSuperhero": "Black Panther"  
},  
{  
"Username": "sportsfanatic88",  
"Lastname": "Anderson",  
"Firstname": "Jack",  
"Birthdate": "1988-10-30",  
"Password": "goteamgo",  
"FavoriteIceCream": "Cookies and Cream",  
"FavoriteSuperhero": "Captain America"  
}  
]

Output:

-- Inserting records into dbo.Users table

INSERT INTO dbo.Users (Username, Lastname, Firstname, Birthdate, Password, FavoriteIceCream, FavoriteSuperhero)
VALUES 
('musiclover87', 'Smith', 'Alice', '1987-06-12', 'password123', 'Chocolate Chip Cookie Dough', 'Spider-Man'),
('bookworm92', 'Johnson', 'Bob', '1992-03-21', 'securePassword', 'Mint Chocolate Chip', 'Batman'),
('gamergirl01', 'Williams', 'Carol', '2001-11-05', 'gamer4life', 'Strawberry', 'Wonder Woman'),
('techieguy95', 'Brown', 'David', '1995-08-18', 'techmaster', 'Vanilla Bean', 'Iron Man'),
('foodiequeen89', 'Davis', 'Emily', '1989-04-29', 'delicious123', 'Salted Caramel', 'Captain Marvel'),
('traveler76', 'Miller', 'Frank', '1976-12-02', 'adventuretime', 'Coffee', 'Thor'),
('fitnessfanatic98', 'Wilson', 'Grace', '1998-09-15', 'strongandfit', 'Mango Sorbet', 'Black Widow'),
('photographylover85', 'Moore', 'Henry', '1985-05-23', 'pictureperfect', 'Pistachio', 'Superman'),
('musicjunkie93', 'Taylor', 'Isabella', '1993-02-08', 'musicislife', 'Rocky Road', 'Black Panther'),
('sportsfanatic88', 'Anderson', 'Jack', '1988-10-30', 'goteamgo', 'Cookies and Cream', 'Captain America');

3. Seamless Code Translation

Code translation is another area where Generative AI proves invaluable. During a recent project to convert a C# application to Python, we utilized AI in two crucial ways:

1. Direct function conversion from Python to C#

2. Complex ORM translation from Entity Framework to SQLAlchemy

This capability significantly accelerated our migration process and ensured consistency across translations.

Converting Python to C#:

Prompt:

Convert the following Python code to C#.

def reverse_string(text): 
"""
Reverses a given string. 
	Args: text: The string to be reversed. 

Returns: The reversed string.

""" 
return text[::-1]

Output:

/// <summary>
/// Reverses a given string.
/// </summary>
/// <param name="text">The string to be reversed.</param>
/// <returns>The reversed string.</returns>
public static string ReverseString(string text)
{
	return new string(text.Reverse().ToArray());
}

4. Automated Code Documentation

Documentation is essential but often tedious. Generative AI streamlines this process in two ways:

1. Code summarization: Analyzing existing code and providing clear, concise summaries

2. Documentation header generation: Creating comprehensive method documentation that maintains code quality standards

For example, when documenting sorting algorithms or complex business logic, AI can generate clear, accurate documentation that follows team standards and best practices.

Prompt:

Generate a doc header for the below function adding the header and printing the complete function with the doc header.

def bubble_sort(list_):
  n = len(list_) 
  for i in range(n):
    # Flag to optimize, if no swaps occur, the list is sorted
    swapped = False
    # Last i elements are already in place
    for j in range(0, n-i-1):
      # Swap if the element found is greater than the next element
      if list_[j] > list_[j+1]:
        list_[j], list_[j+1] = list_[j+1], list_[j]
        swapped = True
    # If no two elements were swapped in inner loop, the list is sorted
    if not swapped:
      break
  return list_

Output:

def bubble_sort(list_):
    """
    Sorts a given list using the Bubble Sort algorithm.

    Args:
        list_: The list of elements to be sorted. Elements must be comparable.

    Returns:
        A new list containing all elements from the original list in ascending order.
        
    Example:
        >>> bubble_sort([64, 34, 25, 12, 22, 11, 90])
        [11, 12, 22, 25, 34, 64, 90]
    """
    n = len(list_) 
    for i in range(n):
        # Flag to optimize, if no swaps occur, the list is sorted
        swapped = False
        # Last i elements are already in place
        for j in range(0, n-i-1):
            # Swap if the element found is greater than the next element
            if list_[j] > list_[j+1]:
                list_[j], list_[j+1] = list_[j+1], list_[j]
                swapped = True
        # If no two elements were swapped in inner loop, the list is sorted
        if not swapped:
            break
    return list_

5. Application Scaffolding

Perhaps the most impressive application of Generative AI is its ability to generate initial application structures. Given a clear schema or specification, AI can create:

• Database creation scripts

• ORM mappings

• Basic API endpoints

• Initial UI implementations

This capability significantly reduces the time spent on boilerplate code and ensures a consistent foundation for further development.

Prompt:

You are a Software Engineer working at a large corporation. Using the following database schema, generate the SQL scripts necessary to create these tables in Postgres. Then, generate the SQL Alchemy mapping files to use with FastAPI. Lastly, generate a simple web UI using FastAPI to list the orders.

User
- UserId
- FirstName
- LastName
- Address
- Address2
- City
- State
- ZipCode
- Username
- Password
- IsActive

Client
- ClientId
- Name
- Address
- Address2
- City
- State
- ZipCode
- IsActive

Order
- OrderId
- OrderDate
- InvoiceNumber
- DueDate
- ClientId
- UserId

OrderDetail
- OrderDetailId
- OrderId
- Description
- Rate
- Quantity
- LineTotal

Ledger
- TransactionId
- Debit
- Credit
- OrderId
- TransactionDate

Output:

...
I'm saving you from the output, but it generated an entire application using FastAPI.
...

Let’s ask what we can do to improve upon the initial design.

Prompt 2:

That's a great start. What can we do to improve the application design?

Output:
Implement logging for better debugging and error handling.

logging.py (Optional)

import logging

logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)

def log_error(error):
    logger.error(f"An error occurred: {error}")

Prompt 3:

Can you implement your suggestion to use Error Handling and generate the code for me?

Output:
You can also define global exception handlers in your main.py file if you want to handle specific exceptions globally.

main.py

from fastapi import FastAPI, Request
from fastapi.responses import JSONResponse
import app.routers.order_router as order_router
from .exceptions import OrderNotFoundException, InvalidInvoiceNumberException

app = FastAPI()

# Include the router
app.include_router(order_router.router)

@app.exception_handler(OrderNotFoundException)
async def order_not_found_exception_handler(request: Request, exc: OrderNotFoundException):
    return JSONResponse(
        status_code=exc.status_code,
        content={"detail": exc.detail},
    )

@app.exception_handler(InvalidInvoiceNumberException)
async def invalid_invoice_number_exception_handler(request: Request, exc: InvalidInvoiceNumberException):
    return JSONResponse(
        status_code=exc.status_code,
        content={"detail": exc.detail},
    )

Best Practices and Considerations

While Generative AI is powerful, it's important to:

• Review and validate generated code

• Maintain consistency with existing codebases

• Consider security implications

• Test generated code thoroughly

• Use AI as an assistant rather than a replacement for engineering judgment

Conclusion

Generative AI has become an indispensable tool in modern software development. By leveraging these five approaches - enhanced searching, code generation, translation, documentation, and application scaffolding - developers can significantly increase their productivity while maintaining code quality.

The key is understanding these tools' capabilities and limitations and strategically using them to enhance rather than replace human expertise. As these technologies evolve, their integration into development workflows will become increasingly valuable.

Author's Note: Chuck Conway specializes in software engineering and AI. Connect with him on social media: X(@chuckconway) or visit him on YouTube.