AI coding tools are everywhere.

Every week, another tool promises to make developers faster, eliminate repetitive coding, or turn a simple prompt into a complete application.

But here’s the problem: having more AI tools doesn’t automatically make you a better developer.

Some are excellent at autocomplete but struggle with larger tasks. Others can edit entire projects but require careful supervision. A few are surprisingly useful for beginners, while others make more sense for experienced developers.

So instead of treating every AI coding assistant as revolutionary, let’s look at 12 popular options and identify the seven worth exploring.

This is a practical comparison of their capabilities and workflows, not a claim that every tool was personally tested under identical conditions.

The 12 AI Coding Tools on the List

Here are the tools we’re comparing:

1. Curso
2. Claude Code
3. GitHub Copilot
4. Windsurf
5. Replit
6. Aider
7. Continue

Gemini Code Assist

1. Amazon Q Developer
2. Sourcegraph Cody
3. Tabnine
4. OpenAI Codex

The goal isn’t to find one universal winner. It’s to understand which tools solve different development problems.

The 7 AI Coding Tools Worth Your Time

1. Cursor — Best for Everyday AI-Assisted Coding

If I had to recommend one starting point for developers who want an AI-powered coding environment, Cursor would be high on the list.

Cursor is built around a familiar code-editor experience, making it easier for developers to transition from traditional editing to AI-assisted development.

Instead of switching between your editor and a chatbot, you can ask questions, generate code, modify files, and work with project context in one environment.

What makes it useful?

• Understands context across project files.
• Generates code from natural-language instructions.
• Helps refactor existing code.
• Supports multi-file editing.
• Provides agent-style coding workflows.

Example:

Imagine you’re building an expense-tracking application.

You can ask:

Create an expense tracking application using Python.
Include:
- User registration
- Expense categories
- Monthly expense summaries
- SQLite database
- A simple dashboard
Organize the code into separate modules.

Cursor can help create the initial structure and implement different components.

You still need to review the code, but it can make the development process more efficient.

My verdict: A strong choice for developers who want an AI assistant integrated into their everyday coding environment.

Website: https://cursor.com/

2. Claude Code — Best for Complex Development Tasks

Claude Code is different from a traditional autocomplete assistant.

It works as an agentic coding tool, allowing developers to interact with their projects through the terminal and supported integrations.

You can ask it to inspect a codebase, investigate an error, modify files, run tests, and work through a development task.

This is particularly useful when a problem involves multiple files rather than one isolated function.

What makes it stand out?

• Understands existing project structures.
• Can modify multiple files.
• Helps investigate bugs.
• Can execute development commands.
• Supports multi-step coding workflows.

Example:

Suppose you inherit a Python project written by another developer.

You don’t know how its components connect.

You can ask:

Analyze this Python project.
Explain:
1. Its overall architecture
2. The purpose of each major module
3. How data moves through the application
4. Potential bugs and security concerns
5. Areas that need refactoring

Claude Code can inspect the available project files and help you understand the application.

My verdict: Particularly worth exploring when working with existing codebases and complex development tasks.

Website: https://claude.com/product/claude-code

3. GitHub Copilot — Best for Daily Coding Assistance

GitHub Copilot is one of the most recognizable names in AI-assisted development.

Its biggest advantage is that it fits naturally into an existing coding workflow.

You don’t need to explain every small task to a separate chatbot. Copilot can suggest code while you’re writing it and provide assistance through supported editor features.

Useful capabilities:

• Intelligent code completion.
• Code generation.
• Code explanations.
• Debugging assistance.
• Test generation.
• Agentic coding features in supported environments.

For example, imagine you’re writing a Python function to validate email addresses.

You can start with:

def validate_email(email):

Copilot can suggest an implementation based on the surrounding code and your instructions.

You can then review, modify, and test the suggestion.

My verdict: A practical option for developers who want AI assistance without significantly changing their existing workflow.

Website: https://github.com/features/copilot

4. Windsurf — Best for Agentic Development Workflows

Windsurf is an AI-powered development environment built around the idea of making AI a more active coding partner.

Its Cascade feature helps developers work through tasks involving project context, code changes, and debugging.

Think about adding authentication to an existing application.

You need to identify the relevant files, understand the current architecture, implement the feature, and check that everything works.

Windsurf is designed to assist across these connected steps.

Why it’s worth exploring:

• AI-powered code generation.
• Context-aware assistance.
• Multi-file changes.
• Debugging support.
• Agent-style workflows.

Example prompt:

Add user authentication to this application.
Requirements:
- User registration
- Secure password hashing
- Login and logout
- Input validation
- Appropriate error handling
Follow the existing project structure.

Windsurf can help plan and implement the changes.

My verdict: Worth considering if you want an AI-first development environment rather than just autocomplete.

Website: https://windsurf.com/

5. OpenAI Codex — Best for Delegating Coding Tasks

OpenAI Codex is designed to help developers delegate software engineering tasks to AI agents.

Rather than only suggesting the next line of code, Codex can work through development tasks in supported environments, inspect repositories, make changes, and run tests.

This makes it interesting for developers who want to assign well-defined tasks and review the resulting work.

What can it help with?

• Implementing features.
• Fixing bugs.
• Understanding unfamiliar code.
• Writing and running test
• Reviewing proposed changes.
• Working on development tasks in parallel.

Example:

You have an application with a broken password-reset feature.

Instead of asking for a generic explanation, you can provide a task:

Investigate the password-reset functionality.
Find the cause of the failure.
Review the relevant files.
Fix the issue.
Add tests for the affected behavior.
Explain the changes you made.

Codex can work through the task in its supported coding environment.

The important part is reviewing the changes before merging them into your main project.

My verdict: One of the most interesting options for developers exploring agent-based software development.

Website: https://openai.com/codex/

6. Replit — Best for Beginners and Rapid Prototyping

Replit makes application development accessible through a browser-based environment.

You don’t need to spend hours setting up a local development environment before experimenting with an idea.

Its AI features can help turn natural-language descriptions into application prototypes.

What makes it useful?

• Browser-based coding.
• AI-assisted application creation.
• Code execution.
• Collaboration features.
• Deployment options.

Example:

Suppose you want to create a personal task manager.

You can describe the application:

Build a task management application.
Users should be able to:
- Add new tasks
- Set deadlines
- Mark tasks as completed
- Filter tasks by status
- View pending tasks
Create a clean and simple interface.

Replit can help generate a starting application that you can test and improve.

My verdict: A good starting point for beginners, students, and developers who want to prototype ideas quickly.

Website: https://replit.com/

7. Aider — Best for Developers Who Prefer the Terminal

Aider is an open-source AI pair-programming tool that works with your local Git repository.

It is especially interesting because it brings AI assistance into a terminal-based development workflow.

You describe the changes you want, and Aider helps modify the relevant files.

Its Git integration also makes it easier to track changes.

Why developers might prefer it:

• Works with existing Git repositories.
• Supports multiple AI models.
• Helps edit several files.
• Provides Git-aware workflows.
• Fits into terminal-based development.

Example:

You want to improve error handling across a Python project.

You can ask:

Review the Python project.
Find functions that lack proper error handling.
Add appropriate exception handling.
Avoid hiding unexpected errors.
Keep the existing coding style.

Aider can help implement the requested changes.

My verdict: A useful option for developers who prefer open-source tools and command-line workflows.

Website: https://aider.chat/

What About the Other Five Tools?

The remaining five aren’t necessarily bad. They simply serve more specific needs or may be less compelling as a general starting point.

ToolWhat It DoesWhy You Might Choose It Continue Customizable AI coding assistantYou want model flexibility and controlGemini Code Assist Google’s AI coding assistantYou work with Google Cloud and related toolsAmazon Q DeveloperAI assistance for AWS developmentYour projects use AWS services Sourcegraph CodyCodebase-aware AI assistanceYou work with large code repositories Tabnine AI code completion and assistanceYou prioritize coding assistance and enterprise-focused workflows

One important distinction: AI coding products change quickly. Features, model support, pricing, and integrations can differ between plans and versions. Check each official website before choosing a subscription.

Quick Comparison: Which One Should You Pick?

Your Goal Tool to Explore Everyday AI-assisted coding Cursor Complex development tasksClaude CodeCode completionGitHub CopilotAgentic development environment Windsurf Delegating coding tasksOpenAI CodexBuilding quick prototypesReplitTerminal-based AI coding Aider

There isn’t one tool that wins every category.

The right choice depends on your programming experience, project size, preferred workflow, and budget.

How I’d Build a Practical AI Coding Workflow

The biggest mistake developers make is installing several AI coding tools without knowing what each one should do.

A better approach is to assign each tool a purpose.

Here’s an example workflow:

Step 1: Understand the project

Use an AI assistant to explain the requirements, review the project structure, and identify the components you need.

Step 2: Build the application

Use your primary coding environment, such as Cursor, to implement features and modify files.

Step 3: Handle complex tasks

Use an agentic tool such as Claude Code or Codex when a task requires deeper project investigation or several connected changes.

Step 4: Test everything

Use Python’s pytest, automated tests, and manual checks to verify that the generated code actually works.

Step 5: Review changes

Use Git to inspect differences, track modifications, and keep your project organized.

This workflow is more valuable than using five coding assistants simultaneously.

Final Thoughts

AI coding tools are changing how developers build software.

But the most useful tool isn’t necessarily the one with the most impressive demonstration. It’s the one that consistently solves a problem in your actual workflow.

If you’re starting, explore Replit or GitHub Copilot.

If you’re developing larger applications, look at Cursor, Claude Code, Windsurf, and Codex.

If you prefer working in the terminal, Aider deserves a closer look.

My biggest recommendation is simple: choose one tool, build a real project, and learn how to review its output.

AI can help you write code faster. Understanding that code is what makes you a developer.

I Tried 12 AI Coding Tools. These 7 Are Worth Your Time. was originally published in CodeToDeploy on Medium, where people are continuing the conversation by highlighting and responding to this story.

A few years ago, AI coding meant asking a chatbot to generate a function and copying the result into your editor.

That workflow has changed.

In 2026, AI coding tools can understand entire codebases, suggest architectural changes, generate tests, explain complicated errors, edit multiple files, and even execute development tasks through an agent-based workflow.

But there is one problem: there are so many tools that choosing the right ones has become a task of its own.

You don’t need every AI coding assistant. You need a small toolkit that solves real development problems.

Here are nine tools worth knowing.

1. Cursor — An AI-Powered Code Editor

If you want an AI assistant directly inside your development environment, Cursor is one of the first tools to explore.

Cursor is an AI-powered code editor built around the familiar VS Code experience. It helps developers understand existing code, generate new features, make changes across files, and fix errors without constantly switching between applications.

What makes it useful?

• Understands context across multiple files.
• Generates code from natural-language instructions.
• Helps refactor existing functions and components.
• Suggests fixes when something breaks.
• Supports agent-style coding workflows.

Example:

Imagine you’re building a Python expense tracker. Instead of manually creating every component, you can ask Cursor:

Create a Python expense tracker with:
- User registration and login
- Expense categories
- Monthly spending summaries
- SQLite database integration
- A simple dashboard

Cursor can help create the project structure and implement the different components.

You still need to review the generated code, but it can reduce the amount of repetitive work.

Best for: Developers who want AI assistance throughout their coding workflow.

Website: https://cursor.com/

2. Claude Code — An AI Agent for Your Development Workflow

Claude Code takes AI-assisted programming beyond simple code suggestions.

It is an agentic coding tool that can work with your project through the terminal. You can ask it to inspect files, understand how different components connect, modify code, run commands, and help investigate bugs.

Instead of asking for one function at a time, you can describe a complete development task.

For example:

Review this Python project.
Identify:
1. Repeated code
2. Functions that are difficult to maintain
3. Potential bugs
4. Missing error handling
Suggest improvements and explain each change.

Claude Code can inspect the project and work through the task using the available tools and permissions.

Why developers should know it:

• Works with existing codebases.
• Can modify multiple files.
• Helps investigate complicated bugs.
• Can run tests and inspect their results.
• Supports structured development workflows.

Best for: Developers working on larger projects who want an AI agent capable of handling multi-step coding tasks.

Website: https://claude.com/product/claude-code

3. GitHub Copilot — Your AI Pair Programmer

GitHub Copilot is one of the most established AI coding assistants.

It integrates with popular development environments and helps developers write code while they work.

Its main advantage is convenience. You don’t have to stop coding, open a separate chatbot, explain your entire problem, and copy the response back.

Copilot can suggest code directly in your editor.

Useful features includ

• Code completion and suggestions.
• Natural-language code explanations.
• Assistance with debugging.
• Test generation.
• Chat-based coding assistance.
• Agentic coding capabilities in supported environments and workflows.

Example:

You are writing a Python function:

def calculate_average(numbers):

You can describe what you want through a comment:

# Calculate the average of a list.
# Return 0 if the list is empty.

Copilot can suggest an implementation:

def calculate_average(numbers):
    if not numbers:
        return 0
return sum(numbers) / len(numbers)

It is a small example, but this kind of assistance becomes valuable when repeated throughout a project.

Best for: Developers who want convenient AI assistance while writing everyday code.

Website: https://github.com/features/copilot

4. Windsurf — An AI-First Development Environment

Windsurf is an AI-powered development environment designed to make coding feel more collaborative.

Its Cascade feature helps developers work through multi-step tasks by understanding project context and assisting with code changes.

Think about a situation where you need to add a feature to an application.

You must understand the existing files, identify where the feature belongs, modify the relevant components, and check whether everything works.

Windsurf aims to help with this entire process.

What makes it interesting?

• Understands project context.
• Helps implement features across files.
• Supports debugging and code generation.
• Provides an agent-style development experience.
• Helps developers navigate unfamiliar projects.

Example prompt:

Add a password reset feature to this application.
Include:
- Email-based reset requests
- Secure reset tokens
- Token expiration
- Password validation
- Error handling

Windsurf can help plan and implement the required changes.

Best for: Developers who prefer an AI-first editor with assistance across larger coding tasks.

Website: https://windsurf.com/

5. Replit — Build Applications Without Complicated Setup

Not every developer wants to spend hours configuring environments before writing their first line of code.

This is where Replit becomes useful.

Replit is an online development platform that lets you write, run, and deploy applications. Its AI features help users turn ideas into working prototypes and improve existing projects.

It is especially useful for beginners, students, and developers who want to experiment quickly.

What can you do with it?

• Create applications using natural-language instructions.
• Write and execute code in the browser
• Build prototypes
• Collaborate on projects.
• Deploy supported applications.

Example:

Suppose you want to build a simple task management application.

You can describe the idea:

Build a task management application
Users should be able to:
- Add tasks
- Set deadlines
- Mark tasks as completed
- Filter tasks by status
- View pending tasks

Replit can help turn the description into a starting application.

You can then test it, make improvements, and work toward deployment.

Best for: Beginners, students, rapid prototyping, and developers who prefer browser-based development.

Website: https://replit.com/

6. Aider — AI Pair Programming in Your Terminal

Aider is an open-source AI pair-programming tool that works directly with your local Git repository.

Unlike traditional coding assistants that focus primarily on editor suggestions, Aider allows you to describe changes and collaborate with an AI model through the terminal.

One particularly useful feature is its Git integration.

It can help make code changes and create Git commits, giving you a clearer record of development work.

Why developers might like it:

• Works with existing Git repositories.
• Helps edit multiple files.
• Supports different AI models.
• Shows changes through Git diffs.
• Fits naturally into terminal-based workflows.

Example:

You have a Python application with several files and want to add logging.

You can ask:

Add structured logging to this project.

Aider can help make the changes while keeping the work connected to your repository.

Best for: Python developers, terminal enthusiasts, and developers who prefer open-source tools.

Website: https://aider.chat/

7. Continue — Customize Your AI Coding Assistant

Continue is an open-source AI coding assistant that integrates with development environments such as VS Code and JetBrains IDEs.

Its biggest advantage is flexibility.

Instead of being locked into one specific AI model or workflow, developers can configure different models and customize how the assistant behaves.

This makes it interesting for developers who want more control over their development environment.

What can you use it for?

• Code generation.
• Code explanations.
• Editing existing code.
• Context-aware assistance.
• Custom AI workflows.
• Integration with different supported models

For example, a developer can configure Continue to use a preferred model and create workflows for reviewing code or explaining unfamiliar functions.

Best for: Developers who want an adaptable, customizable AI coding assistant.

Website: https://www.continue.dev/

8. Amazon Q Developer — AI Assistance for AWS Development

Developers working with cloud applications often face challenges that go beyond writing code.

They need to understand cloud services, configure infrastructure, troubleshoot errors, and manage security.

Amazon Q Developer is an AI-powered assistant designed to support software development, with capabilities particularly relevant to the AWS ecosystem.

Useful capabilities include:

• Code suggestions and generation.
• Code explanations.
• Help with AWS services.
• Troubleshooting and development assistance.
• Security-related code analysis in supported workflows.
• Assistance with AWS infrastructure tasks.

Example:

Imagine you’re developing a Python application that uploads files to Amazon S3.

You can ask for help creating an upload function using the AWS SDK for Python, Boto3.

import boto3
def upload_file(file_path, bucket, object_name):
    s3 = boto3.client("s3")
    s3.upload_file(
        file_path,
        bucket,
        object_name
    )

An AI assistant can help explain the code, identify missing error handling, and suggest improvements.

Remember that cloud permissions, credentials, and security configurations still require careful review.

Best for: Developers building applications within the AWS ecosystem.

Website: https://aws.amazon.com/q/developer/

9. Gemini Code Assist — AI Coding Across Google’s Ecosystem

Gemini Code Assist is Google’s AI coding assistant for developers.

It provides coding assistance through supported development environments and Google Cloud workflows.

It can help developers generate code, understand unfamiliar functions, troubleshoot issues, and work with larger codebases.

What makes it useful?

• Code completion.
• Natural-language code generation.
• Code explanations.
• Assistance with debugging.
• Support for multiple programming languages.
• Integration with Google’s development ecosystem.

Example:

Suppose you’re working with a Python script that processes Excel files.

You can ask:

Write a Python function using pandas
that reads an Excel file, removes duplicate rows,
handles missing values, and saves the cleaned
data into a new Excel file.

Gemini Code Assist can help generate the implementation and explain the steps.

Best for: Developers who want AI coding assistance and work with Google’s development tools and cloud services.

Website: https://codeassist.google/

Quick Comparison: Which AI Coding Tool Should You Choose?

You don’t need to install all nine tools. The best choice depends on how you develop software.

ToolMain StrengthBest ForCursorAI-powered code editingEveryday developmentClaude CodeAgentic codingComplex projectsGitHub CopilotCode completionDaily coding assistanceWindsurfAI-first developmentMulti-file tasksReplitBrowser-based buildingBeginners and prototypesAiderTerminal-based codingGit-focused developersContinueCustomizable AI assistanceFlexible workflowsAmazon Q DeveloperAWS developmentCloud developersGemini Code AssistGoogle’s coding ecosystem General development and Google Cloud

How to Choose the Right AI Coding Tools

Instead of choosing tools because everyone is talking about them, start with your actual development needs.

Here is a simple approach:

If you’re a beginner:

Start with Replit and GitHub Copilot. Focus on learning programming fundamentals while using AI to understand errors and explore unfamiliar concepts.

If you’re a Python developer:

Explore Cursor, Aider, and Claude Code. These can help with project development, debugging, refactoring, and multi-file changes.

If you’re building larger applications:

Consider Cursor, Windsurf, or Claude Code for more involved coding workflows.

If you’re interested in cloud development:

Explore Amazon Q Developer and Gemini Code Assist, depending on your preferred cloud ecosystem.

If you want flexibility:

Try Continue or Aider. Both offer workflows that appeal to developers who want more control over their AI tools.

The Real Skill Is Knowing How to Work With AI

AI coding tools can generate impressive amounts of code, but generating code and building reliable software are two different things.

A developer still needs to understand:

• Programming fundamentals.
• Data structures and algorithms.
• Debugging.
• Database design.
• API development.
• Testing and security.
• Software architecture.

Consider this simple workflow:

1. Use an AI assistant to understand the requirements.
2. Ask it to propose a project structure.
3. Generate one component at a time.
4. Review the code before accepting changes.
5. Run tests and check edge cases.
6. Use Git to track changes.
7. Test the complete application before deployment.

Never assume generated code is correct simply because it looks professional.

AI can introduce bugs, insecure configurations, outdated approaches, and unnecessary complexity. Review its output, protect credentials, and avoid giving coding agents unrestricted access to sensitive files or production systems.

Final Thoughts

The future of software development isn’t necessarily about replacing developers with AI. It’s about changing how developers approach problems.

Tools like Cursor, Claude Code, GitHub Copilot, and Aider can reduce repetitive work. Platforms like Replit can make experimentation easier. Tools like Amazon Q Developer and Gemini Code Assist can support development within larger cloud ecosystems.

But the biggest advantage doesn’t come from using the most AI tools.

It comes from knowing when to use them, how to guide them, and how to recognize when their output is wrong.

Start with one tool. Build a real project. Learn its strengths and limitations.

That’s how you turn AI coding from an interesting experiment into a practical development skill.

9 AI Coding Tools Every Developer Should Know in 2026 was originally published in Level Up Coding on Medium, where people are continuing the conversation by highlighting and responding to this story.

A few years ago, developers spent hours searching for solutions, reading documentation, debugging errors, and writing repetitive code. Today, AI coding tools can help with many of these tasks.

You can describe a feature in plain English, generate a Python function, ask AI to explain an unfamiliar codebase, or automate parts of your testing workflow.

But there’s a catch.

Not every AI coding tool improves productivity. Some generate code that needs extensive correction. Others are useful for specific tasks but unnecessary in an everyday development workflow.

The goal isn’t to use as many AI tools as possible. It’s to find the right tools for the problems you encounter.

Here are 10 AI coding tools worth exploring if you want to write better code, reduce repetitive work, and improve your development workflow.

1. Cursor — An AI-Powered Code Editor

<AsyncImage query=” Cursor AI code editor agent mode interface screenshot” aspectRatio=”16:9"/>

Imagine working on a Python project with 30 files. You need to add a new feature, but first you must understand how the existing functions and modules connect.

Instead of manually inspecting everything, you can use <Entity value=” Cursor” category=” software” disambig=” AI-powered code editor”/> to help explore the codebase.

Cursor combines a familiar code editor experience with AI-powered coding assistance.

You can ask it to explain code, generate functions, refactor files, and help implement features across your project.

Useful features:

• AI-powered code completion.
• Codebase-aware assistance.
• Multi-file editing.
• Bug investigation.
• Agent-style development workflows.

Example prompt:

“Analyze this Python project. Explain its folder structure, identify the main application entry point, and describe how the modules interact.”

Best for: Developers who want AI assistance directly inside their main coding environment.

Website: https://cursor.com

2. GitHub Copilot — Your Everyday Coding Assistant

<AsyncImage query=”GitHub Copilot Visual Studio Code inline code suggestions interface” aspectRatio=”16:9"/>

Sometimes you don’t need an AI agent to modify an entire project. You just need help completing a function or understanding a complicated line of code.

That’s where <Entity value=”GitHub Copilot” category=”software” disambig=”AI coding assistant by GitHub”/> becomes useful.

It integrates with supported development environments and helps developers write code through suggestions, explanations, and chat-based assistance.

For example, imagine writing a Python function to clean an Excel dataset.

You could start with a comment:

# Read an Excel file, remove duplicate rows,
# remove empty records, and save the cleaned file.

Copilot can suggest an implementation based on the context of your code.

You can also ask it to explain existing functions or help generate tests.

Useful features:

• Inline code suggestions.
• Function generation.
• Code explanations.
• Test generation.
• AI-assisted debugging.

Best for: Developers who want convenient coding assistance without changing their entire workflow.

Website: https://github.com/features/copilot

3. Claude Code — Automate Multi-Step Coding Tasks

<AsyncImage query=”Anthropic Claude Code terminal AI coding agent interface” aspectRatio=”16:9"/>

Writing code is only one part of software development.

You also need to inspect files, understand dependencies, modify existing functionality, run tests, and fix errors.

<Entity value=”Claude Code” category=”software” disambig=”Agentic coding tool by Anthropic”/> is designed to help with these broader development tasks.

It works through the terminal and can inspect your project, edit files, execute commands, and assist with multi-step coding workflows.

Imagine you have a FastAPI application and want to add user authentication.

You could ask:

“Inspect this project and implement user authentication using its existing architecture. Add the necessary routes, input validation, and tests. Explain the changes you make.”

Claude Code can work through the project and help implement the requested changes.

Useful features:

• Project exploration.
• Multi-file code editing.
• Test execution.
• Debugging assistance.
• Complex development workflows.

Best for: Developers working with existing codebases and larger development tasks.

Website: https://code.claude.com

4. Windsurf — An AI-First Development Environment

<AsyncImage query=”Windsurf IDE Cascade AI coding assistant editor interface” aspectRatio=”16:9"/>

<Entity value=”Windsurf” category=”software” disambig=”AI-powered integrated development environment”/> is designed around the idea of making AI a central part of the development experience.

Its Cascade assistant helps developers interact with their projects through natural-language instructions.

For example, you could ask:

“Create a responsive dashboard with a sidebar, navigation menu, and analytics section. Organize the components into separate files.”

Windsurf can help generate the initial implementation and make changes across the project.

Useful features:

• AI-powered coding assistance.
• Codebase context.
• Multi-file editing.
• Agentic development workflows.
• Integrated development environment.

Best for: Developers who prefer a conversational, AI-first coding environment.

Website: https://windsurf.com

5. Replit — Build and Run Applications in Your Browser

<AsyncImage query=”Replit AI application development workspace agent interface” aspectRatio=”16:9"/>

What if you have an application idea but don’t want to spend hours configuring your local development environment?

<Entity value=”Replit” category=”software” disambig=”Online software development platform with AI features”/> provides a browser-based environment where you can write, run, and develop applications.

Its AI-powered agent can help turn a written description into an application prototype.

For example:

“Build a student expense tracker with a login page, expense categories, monthly summaries, and a dashboard.”

Replit can help generate the initial application and assist with further development.

Useful features:

• Browser-based coding.
• AI-assisted application creation.
• Integrated execution environment.
• Collaboration capabilities.

Deployment options.

Best for: Beginners, rapid prototyping, and developers who want to experiment with application ideas.

Website: https://replit.com

6. Aider — AI Pair Programming From Your Terminal

<AsyncImage query=”Aider AI coding assistant terminal git interface” aspectRatio=”16:9"/>

If you enjoy working with command-line tools, <Entity value=”Aider” category=”software” disambig=”Open-source AI pair programming tool”/> deserves a place on your list.

Aider connects AI models to your local codebase and helps you modify files through conversational instructions.

Imagine having a Python application with a function that incorrectly processes customer records.

You could ask:

“Find the problem in the customer processing function, fix it, and add tests for invalid records without changing unrelated functionality.”

Aider can help edit the relevant files and integrate its changes with Git.

Useful features

• Terminal-based coding.
• Multi-file editing.
• Git integration.
• Refactoring assistance.
• Support for different AI models.

Best for: Developers who prefer terminal-based workflows and want AI-assisted pair programming.

Website: https://aider.chat

7. Continue — Customize Your AI Coding Workflow

<AsyncImage query=”Continue.dev AI coding assistant VS Code interface” aspectRatio=”16:9"/>

Not every developer wants to change their editor or depend on a single AI provider.

<Entity value=”Continue” category=”software” disambig=”Open-source AI coding assistant for developer IDEs”/> offers an extensible approach to AI-assisted development.

It can help developers understand code, generate functions, and make changes inside supported development environments.

One of its interesting aspects is the ability to configure different supported AI models and customize workflows.

Useful features:

• Code generation.
• Code explanations.
• AI-assisted editing.
• Model configuration.
• Customizable development workflows.

Best for: Developers who want more control over their AI coding environment.

Website: https://www.continue.dev

8. Amazon Q Developer — AI Assistance for AWS Development

<AsyncImage query=”Amazon Q Developer IDE coding assistant interface” aspectRatio=”16:9"/>

If you’re developing applications using Amazon Web Services, <Entity value=”Amazon Q Developer” category=”software” disambig=”AI assistant for software development by AWS”/> is worth exploring.

It provides AI-powered assistance for coding and working with AWS-related development tasks.

For example, if you’re building a Python application that uses Amazon S3, you can ask for help understanding the relevant SDK, generating code, or investigating errors.

Useful features:

• Code suggestions.
• Code explanations.
• AWS development assistance.
• Security-related suggestions.
• Development workflow support.

Best for: Developers building applications within the AWS ecosystem.

Website: https://aws.amazon.com/q/developer/

9. Gemini Code Assist — AI Coding Assistance From Google

<AsyncImage query=”Google Gemini Code Assist VS Code programming interface” aspectRatio=”16:9"/>

<Entity value=”Gemini Code Assist” category=”software” disambig=”AI coding assistant by Google”/> brings Google’s AI capabilities into supported development environments.

It can help developers generate code, understand existing implementations, and work through programming problems.

For example, you could ask it to:

“Write a Python function that reads a JSON file, validates the required fields, and returns a clean dictionary. Include error handling.”

It can help generate an initial implementation that you can review and test.

Useful features:

• Code completion.
• Code generation.
• Code explanations.
• Chat-based coding assistance.
• Support for Google Cloud development workflows.

Best for: Developers who want AI coding assistance and work with Google’s development ecosystem.

Website: https://codeassist.google/

10. Sourcegraph Cody — Understand Large Codebases Faster

<AsyncImage query=”Sourcegraph Cody AI code assistant codebase search interface” aspectRatio=”16:9"/>

One of the most frustrating parts of working on an unfamiliar project is understanding where everything is located.

You might know what needs to change but have no idea which files contain the relevant functionality.

<Entity value=”Sourcegraph Cody” category=”software” disambig=”AI coding assistant and codebase understanding tool”/> has focused on helping developers understand and navigate codebases.

It can assist with questions about code, identify relevant sections, and help developers explore relationships between different parts of a project.

Useful features:

• Codebase exploration.
• Code explanations.
• Context-aware assistance.
• Code search workflows.
• Development support.

Best for: Developers who need help understanding complex or unfamiliar codebases.

Website: https://sourcegraph.com/

Note: Check the current product availability and supported features before adopting Cody, as product offerings can change.

Comparison: Which AI Coding Tool Should You Choose?

You don’t need every tool in this list. Choose according to the kind of development work you perform.

ToolMain strengthBest suited forCursorAI-powered editingEveryday developmentGitHub CopilotCode completionWriting code fasterClaude CodeMulti-step codingComplex project tasksWindsurfAI-first IDEConversational developmentReplitBrowser-based buildingPrototypes and beginnersAiderTerminal-based codingGit-focused workflowsContinueCustomizationFlexible AI assistance Amazon Q DeveloperAWS integrationCloud developmentGemini Code AssistGoogle ecosystemGoogle-related developmentSourcegraph CodyCodebase understandingExploring large projects

My Recommended AI Coding Workflow

Instead of treating these tools as ten separate products, think about how they fit into different stages of software development.

<box border radius=”lg” padding={3} gap={3}> <box align=center gap={1}> <badge color=”info”>Planning</badge> **ChatGPT** <text color=”secondary” size=”sm”>Define requirements, break down features, and plan architecture.</text> </box> <box align=center> <icon name=”arrow-down” color=”secondary”/> </box> <box align=center gap={1}> <badge color=”info”>Development</badge> **Cursor or GitHub Copilot** <text color=”secondary” size=”sm”>Write code, generate functions, and improve implementations.</text> </box> <box align=center> <icon name=”arrow-down” color=”secondary”/> </box> <box align=center gap={1}> <badge color=”info”>Complex Tasks</badge> **Claude Code** <text color=”secondary” size=”sm”>Explore projects and handle multi-step changes.</text> </box> <box align=center> <icon name=”arrow-down” color=”secondary”/> </box> <box align=center gap={1}> <badge color=”success”>Testing and Review</badge> **pytest + Git** <text color=”secondary” size=”sm”>Verify behavior, review changes, and catch errors.</text> </box> </box>

For example, if I were building a Python expense tracker, I’d use this workflow

1. Ask ChatGPT to help define the features and database structure.
2. Use Cursor to develop the application.
3. Use Claude Code for complex changes across multiple files.
4. Generate tests and run them with pytest.
5. Use Git to track changes and return to a working version if something breaks.

This keeps the development process organized without relying on AI to make every decision.

5 Rules for Using AI Coding Tools Effectively

AI coding tools can make development faster, but they can also introduce mistakes.

Keep these principles in mind:

1. Understand the generated code.

Never add code to a project simply because an AI assistant generated it. Understand what the implementation does.

2. Give specific instructions.

Instead of saying “Fix my application,” explain the error, expected behavior, and relevant files.

3. Test every important change.

Use automated tests to check normal inputs, invalid values, and edge cases.

4. Review security-sensitive code.

Authentication, authorization, database queries, and file uploads deserve extra attention.

5. Avoid unnecessary subscriptions.

Start with one coding assistant. Add another only when it solves a problem your current tool doesn’t handle well.

Final Thoughts

AI coding tools are becoming an important part of modern software development.

They can reduce repetitive work, make unfamiliar code easier to understand, and help developers move from ideas to working applications.

But productivity doesn’t come from installing ten AI tools.

It comes from knowing when to use them.

If you’re a beginner, start with Cursor or GitHub Copilot. If you’re working on larger projects, explore Claude Code. If you prefer terminal-based development, try Aider.

Most importantly, continue learning Python, databases, APIs, testing, and Git.

AI can help you write code faster. Your ability to understand, test, and improve that code is what makes you a better developer.

10 AI Coding Tools That Make Developers More Productive was originally published in CodeToDeploy on Medium, where people are continuing the conversation by highlighting and responding to this story.

I’d build a small toolkit.

One tool for writing code. One for understanding unfamiliar projects. One for debugging. One for testing. And a few others to handle the work that happens around software development.

Because here’s something beginners often misunderstand: becoming a better developer isn’t about using the most AI tools. It’s about building a workflow where each tool solves a specific problem.

AI can help you write code faster, but you still need to understand what you’re building, recognize mistakes, test your application, and maintain it.

So, if I had to start from zero, this is the AI coding toolkit I’d build.

1. Cursor — My Main AI Coding Environment

<AsyncImage query=” Cursor AI code editor agent mode interface” aspectRatio=”16:9"/>

I’d start with <Entity value=” Cursor” category=” software” disambig=” AI-powered code editor”/> because I want my primary coding environment and AI assistant in one place.

Cursor provides an editor experience with AI features that can understand project context, generate code, explain functions, and help modify multiple files.

Instead of constantly switching between my editor and a chatbot, I could ask questions directly while working on a project.

For example, imagine I’m building a Python expense tracker.

I could ask:

“Create a dashboard component that displays total expenses, monthly spending, and the five most recent transactions. Keep the components separate and use reusable functions.”

Cursor can help generate the implementation and make changes within the project.

What I’d use it for:

• Writing Python code.
• Understanding unfamiliar files.
• Refactoring functions.
• Generating components.
• Exploring existing codebases.

Why it’s in my toolkit: I want one central environment where most of my development work happens.

Website: https://cursor.com

2. Claude Code — My AI Development Partner

<AsyncImage query=” Claude Code terminal AI coding agent interface” aspectRatio=”16:9"/>

My next addition would be <Entity value=” Claude Code” category=” software” disambig=” Agentic coding tool by Anthropic”/>

Why?

Because writing individual functions is only a small part of software development.

Real projects involve multiple files, dependencies, configuration, testing, and debugging.

Claude Code works through the terminal and can inspect project files, edit code, run commands, and help with multi-step development tasks.

Imagine asking:

“Review this FastAPI project. Identify its structure, explain how authentication works, and suggest improvements to the existing implementation.”

It can investigate the project and help you understand how different parts connect.

I’d use it for:

• Understanding larger codebases.
• Implementing multi-file changes.
• Refactoring existing projects.
• Investigating bugs.
• Running and interpreting tests.

Why it’s in my toolkit: I want an assistant that can help with the entire development task, not just the next line of code.

Website: https://code.claude.com

3. GitHub Copilot — My Everyday Coding Assistant

<AsyncImage query=” GitHub Copilot VS Code inline code completion interface” aspectRatio=”16:9"/>

I wouldn’t ignore <Entity value=” GitHub Copilot” category=” software” disambig=” AI coding assistant by GitHub”/> just because I already have Cursor.

Copilot offers AI-powered coding assistance in supported development environments.

Its usefulness comes from integrating assistance into familiar coding workflows.

For example, while writing a Python function, I could add a comment describing what I want:

# Read a CSV file, remove duplicate rows,
# and save the cleaned dataset.

Copilot can suggest an implementation based on the surrounding code.

I’d use it for:

• Code completion.
• Writing repetitive functions.
• Explaining code.
• Generating tests.
• Getting quick development suggestions.

Why it’s in my toolkit: Sometimes I don’t need an autonomous agent. I just need a helpful suggestion while coding.

Website: https://github.com/features/copilot

4. ChatGPT — My Planning and Problem-Solving Assistant

<AsyncImage query=” ChatGPT coding assistant Python code analysis interface” aspectRatio=”16:9"/>

Before writing code, I want to understand the problem.

That’s where <Entity value=” ChatGPT” category=” software” disambig=” AI assistant by OpenAI”/> would fit into my workflow.

I could use it to:

• Break a large project into smaller tasks.
• Compare different technology choices.
• Understand programming concepts.
• Explain error messages.
• Review code for possible improvements.
• Brainstorm application ideas.
• Create development roadmaps.

For example, instead of asking:

“Build an expense tracker.”

I’d ask:

“I’m building an expense tracker for students. Help me define the essential features, database structure, API endpoints, and development stages. Keep the architecture beginner-friendly.”

This gives me a clearer plan before I start coding.

Why it’s in my toolkit: I want to understand the problem before asking AI to generate the solution.

Website: https://chatgpt.com

5. Perplexity — My Technical Research Assistant

<AsyncImage query=”Perplexity AI research search interface citations” aspectRatio=”16:9"/>

Developers constantly encounter unfamiliar technologies.

You might need to compare two Python libraries, investigate a new framework, or understand a technical concept.

<Entity value=”Perplexity” category=”software” disambig=”AI-powered search and research platform”/> can help with the initial research.

For example, I could ask:

“Compare FastAPI and Django for building a backend for a small SaaS application. Explain their differences in database integration, authentication, scalability, and development complexity. Include reliable sources.”

I’d use it to:

• Discover technical resources.
• Compare frameworks.
• Research unfamiliar libraries.
• Find relevant documentation.
• Explore new development approaches.

One important habit: I’d always open official documentation before implementing something based on an AI-generated explanation.

Why it’s in my toolkit: Good developers don’t just write code. They know how to find and evaluate technical information.

Website: https://www.perplexity.ai

6. Aider — My Terminal-Based Coding Assistant

<AsyncImage query=” Aider AI pair programming terminal interface git” aspectRatio=”16:9"/>

I’d also install <Entity value=” Aider” category=” software” disambig=” Open-source AI pair programming tool”/>

Aider is designed for AI-assisted coding through the terminal.

It can work with your codebase, edit files, and integrate with Git.

Imagine having a Python project with a function that processes customer records incorrectly.

You could ask Aider:

“Find the issue in the customer processing function. Fix it without changing the existing behavior elsewhere and add tests for invalid records.”

Aider can help make the changes while keeping the workflow connected to version control.

I’d use it for:

• Terminal-based coding.
• Refactoring.
• Working with existing projects.
• Multi-file changes.
• Git-assisted development.

Why it’s in my toolkit: I want to become comfortable with professional development workflows, not depend entirely on graphical editors.

Website: https://aider.chat

7. Continue — My Customizme.dev AI coding assistant IDE interface” aspectRatio=”16:9"/>

Not every developer wants to change their editor or rely on one AI provider.

<Entity value=” Continue” category=” software” disambig=” Open-source AI coding assistant for developer IDEs”/> offers an extensible approach to AI assistance in supported development environments.

It can help with code generation, explanations, and editing while allowing developers to configure supported models and workflows.

I’d explore it when I want more control over how AI fits into my development environment.

What I’d use it for:

• Asking questions about code.
• Generating functions.
• Understanding unfamiliar projects.
• Configuring different AI models.
• Customizing coding workflows.

Why it’s in my toolkit: Flexibility matters when your development requirements change.

Website: https://www.continue.dev

8. pytest — My Automated Testing Tool

<AsyncImage query=”pytest Python testing terminal output test results” aspectRatio=”16:9"/>

Here’s where I’d make an important distinction.

Not every useful development tool needs to be an AI tool.

I’d include <Entity value=”pytest” category=” software” disambig=” Python testing framework”/> because AI-generated code needs proper testing.

Imagine writing a function that calculates discounts.

def calculate_discount(price, percentage):
    return price - (price * percentage / 100)

A simple test could look like this:

def test_calculate_discount():
    assert calculate_discount(1000, 10) == 900

You can run your tests using:

pytest

I’d also ask my AI coding assistant to generate tests for:

• Normal inputs.
• Negative values.
• Missing information.
• Unexpected data types.
• Boundary conditions.

The important thing is to review those tests rather than assume they cover every possible failure.

Why it’s in my toolkit: Writing code quickly is useful. Knowing that it behaves correctly is much more important.

Website: https://pytest.org

9. Postman — My API Testing Environment

<AsyncImage query=”Postman API testing workspace request response interface” aspectRatio=”16:9"/>

If I’m building applications with FastAPI or Django REST Framework, I need a way to test API endpoints.

That’s why I’d add <Entity value=”Postman” category=”software” disambig=”API development and testing platform”/>.

Postman lets developers send requests and inspect responses without building a complete frontend.

For example, suppose my application has this endpoint:

POST /users

I can send a JSON request:

{
    "name": "Ali",
    "email": "ali@example.com"
}

Then inspect the response to see whether the application behaves as expected.

I’d use it for

• Testing GET and POST requests.
• Checking API responses.
• Debugging request errors.
• Testing authentication.
• Organizing API collections.

Why it’s in my toolkit: I want to test the backend independently before connecting it to a frontend.

Website: https://www.postman.com

10. n8n — My Automation Layer

<AsyncImage query=”n8n AI workflow automation visual nodes interface” aspectRatio=”16:9"/>

I’d finish my toolkit with <Entity value=”n8n” category=” software” disambig=” Workflow automation and AI orchestration platform”/>

Building an application is one thing. Automating the processes around it is another.

n8n lets you connect APIs, databases, applications, and AI services through visual workflows.

Imagine building a customer support application.

You could create an automation that:

1. Receives a new customer inquiry.
2. Sends the message to an AI model for classification.
3. Identifies the relevant support category.
4. Creates a record in your database or connected service.
5. Sends a notification to the appropriate team.

You can also build workflows for research, reporting, notifications, and data processing.

Why it’s in my toolkit: I want to build applications that do more than respond to user requests. I want them to connect with useful business processes.

Website: https://n8n.io

The Complete AI Coding Toolkit

Here’s how I’d organize these tools based on their main responsibilities.

Development taskToolMain coding environmentCursorMulti-step developmentClaude CodeInline code assistanceGitHub CopilotPlanning and explanationsChatGPTTechnical researchPerplexityTerminal-based codingAiderCustomizable AI assistanceContinueAutomated testingpytestAPI testingPostmanWorkflow automationn8n

You don’t need to install all ten immediately. Several tools have overlapping capabilities.

I’d begin with Cursor, ChatGPT, and pytest. Add the others when a project gives you a genuine reason to use them.

How I’d Connect Everything Into One Workflow

The real advantage comes from combining tools instead of using them randomly.

Here’s the development workflow I’d follow:

<box border radius=”lg” padding={3} gap={3}> <box align=center gap={1}> <badge color=”info”>01 · Planning</badge> **ChatGPT** <text color=”secondary” size=”sm”>Define the problem, features, and architecture.</text> </box> <box align=center> <icon name=”arrow-down” color=”secondary” size=”lg”/> </box> <box align=center gap={1}> <badge color=”info”>02 · Research</badge> **Perplexity** <text color=”secondary” size=”sm”>Research frameworks, libraries, and documentation.</text> </box> <box align=center> <icon name=”arrow-down” color=”secondary” size=”lg”/> </box> <box align=center gap={1}> <badge color=”info”>03 · Development</badge> **Cursor or Claude Code** <text color=”secondary” size=”sm”>Build features and work with the codebase.</text> </box> <box align=center> <icon name=”arrow-down” color=”secondary” size=”lg”/> </box> <box align=center gap={1}> <badge color=”info”>04 · Testing</badge> **pytest and Postman** <text color=”secondary” size=”sm”>Check functions, API endpoints, and edge cases.</text> </box> <box align=center> <icon name=”arrow-down” color=”secondary” size=”lg”/> </box> <box align=center gap={1}> <badge color=”success”>05 · Automation</badge> **n8n** <text color=”secondary” size=”sm”>Connect your application to other services and workflows.</text> </box> </box>

This workflow creates a clear separation between planning, research, development, testing, and automation.

It also gives you opportunities to understand every stage rather than blindly accepting generated code.

If I Were Starting From Scratch: My 30-Day Plan

I’d avoid spending the first month experimenting with every AI coding platform.

Instead, I’d build one useful application.

DaysFocusPractical result1–5Python fundamentals and GitA small Python project6–10Cursor and ChatGPTBuild the first application features11–15FastAPI and databasesWorking backend and API16–20pytest and PostmanTested endpoints and functions21–25Claude Code or AiderRefactor and improve the project26–30n8n and deploymentConnected, usable application

By the end, I’d aim to have one complete project on GitHub with a README, working features, and tests.

That is much more valuable than having ten AI tools installed without knowing how to use them.

Final Thoughts

If I were starting from scratch, I’d build my coding toolkit around one principle:

Every tool should solve a specific development problem.

I wouldn’t use Cursor just because everyone talks about it. I wouldn’t use an AI agent without understanding the changes it makes. And I wouldn’t consider an application complete simply because it runs once.

I’d use AI to reduce repetitive work, learn unfamiliar technologies, and move through development faster.

But I’d still learn Python, understand databases, write tests, use Git, and review my code.

Because AI can help you build software faster, but understanding what you’re building is what makes you a developer.

Don’t build a collection of AI tools. Build a development workflow that makes you better at building software.

The AI Coding Toolkit I’d Build If I Were Starting From Scratch was originally published in Life with Tech on Medium, where people are continuing the conversation by highlighting and responding to this story.

Some promise to write entire applications from a single prompt. Others claim they can debug complex codebases, automate testing, or turn natural language into production-ready software.

But here’s the problem: not every AI coding tool deserves a place in your development workflow.

Some are excellent at generating code but struggle with larger projects. Others make impressive demos but become frustrating when you need to maintain, debug, or understand the code they produce.

The real question isn’t which tool can generate the most code.

It’s which one actually makes developers more productive.

I looked at 10 popular AI coding tools and narrowed the list down to seven that stand out for different development tasks. The remaining three are worth knowing about, but they didn’t make my main shortlist.

Note: This is a practical comparison of their capabilities and use cases, not a claim of personally testing every tool. Features, pricing, and model availability can change.

1. Cursor: The Best All-Round AI Code Editor

<AsyncImage query=” Cursor AI code editor agent mode interface screenshot” aspectRatio=”16:9" />

If you want an AI coding assistant that works directly inside your development environment, start with <Entity value=” Cursor” category=” software” disambig=” AI-powered code editor”/>

Cursor is built around the familiar Visual Studio Code-style editing experience, but adds AI capabilities throughout the development workflow.

Instead of copying code into a chatbot, you can work with AI directly inside your project.

What makes it useful?

• Understands context from your codebase.
• Explains unfamiliar functions and files.
• Generates and edits code.
• Helps identify and fix bugs.
• Assists with refactoring.
• Supports agent-style workflows for multi-step coding tasks.

Imagine joining a project with 30 Python files and very little documentation.

Instead of opening every file individually, you can ask Cursor:

“Explain the structure of this project. Identify the main entry point, important modules, and how data moves through the application.”

It can help you understand the codebase before you start changing anything.

Best for: Developers who want AI assistance throughout their everyday coding workflow.

Website: https://cursor.com

2. Claude Code: An AI Coding Agent That Works With Your Project

<AsyncImage query=” Anthropic Claude Code terminal coding agent interface” aspectRatio=”16:9" />

Most coding assistants help you write individual functions.

<Entity value=”Claude Code” category=”software” disambig=”Agentic coding tool by Anthropic”/> takes a more project-oriented approach.

It works through your terminal and can inspect files, understand project structure, edit code, run commands, and help complete multi-step development tasks.

For example, imagine you want to add authentication to an existing FastAPI application.

You could ask:

“Inspect this project and implement user authentication using the existing structure. Add the necessary routes, validation, and tests. Explain the changes before finishing.”

Claude Code can investigate the project, propose an implementation, and work through the required changes.

Its usefulness comes from handling tasks that involve multiple files rather than generating isolated snippets.

What makes it stand out?

• Terminal-based development workflow.
• Codebase exploration.
• Multi-file code editing.
• Test execution and debugging assistance.
• Support for complex development tasks.

You should still review its changes, especially when it modifies authentication, database operations, or security-sensitive code.

Best for: Developers working on existing projects and complex multi-step coding tasks.

Website: https://code.claude.com

3. GitHub Copilot: The Practical Everyday Coding Assistant

<AsyncImage query=” GitHub Copilot VS Code inline code suggestions chat interface” aspectRatio=”16:9" />

Not every developer needs an autonomous coding agent.

Sometimes, you just want help writing the next function, understanding an unfamiliar API, or generating a repetitive block of code.

That’s where <Entity value=” GitHub Copilot” category=” software” disambig=” AI coding assistant by GitHub”/> fits.

It integrates with supported development environments and provides AI-powered coding assistance.

You can use it for:

• Inline code suggestions.
• Function generation.
• Code explanations.
• Test generation.
• Debugging assistance.
• Documentation support.

For example, while writing a Python function, you can describe what it should do in a comment.

# Create a function that reads a CSV file,
# removes duplicate rows, and saves the cleaned file.

Copilot can suggest an implementation based on the surrounding code and your prompt.

You can then review and adapt the result.

Its strength is convenience. You don’t need to change your entire development workflow to start using it.

Best for: Developers who want coding assistance integrated into their existing editor.

Website: https://github.com/features/copilot

4. Windsurf An AI-First Development Environment

<AsyncImage query=” Windsurf IDE Cascade AI coding assistant interface” aspectRatio=”16:9" />

<Entity value=” Windsurf” category=” software” disambig=” AI-powered integrated development environment”/> is another AI-focused code editor designed to make development more conversational.

Its Cascade experience helps developers interact with their codebase through AI.

You can describe a feature, ask for an explanation, or request changes across different parts of a project.

For example:

“Create a responsive dashboard with a sidebar, navigation menu, and product analytics section. Organize the components into separate files.”

Windsurf can help generate the initial implementation and work through changes.

Why developers may like it:

• AI assistance built into the editor.
• Codebase-aware interactions.
• Multi-file editing.
• Support for agentic development workflows.
• Integrated development experience.

One important consideration is that AI-generated interfaces still need human review for accessibility, responsiveness, performance, and maintainability.

Best for: Developers who prefer an AI-first editor and conversational coding experience.

Website: https://windsurf.com

5. Replit Go From an Idea to a Running Application

<AsyncImage query=” Replit AI app development workspace agent interface” aspectRatio=”16:9" />

What if you have an application idea but don’t want to spend hours configuring your development environment?

<Entity value=” Replit” category=” software” disambig=” Online development platform with AI app-building features”/> makes it possible to create and run projects in an online development environment.

Its AI-powered agent can help turn descriptions into working application prototypes.

For example, you could describe:

“Build a personal expense tracker with a login page, expense categories, monthly summaries, and a dashboard.”

Replit can help create the initial application structure and work through implementation.

You can also use the platform to run, test, and deploy supported projects.

What makes it interesting?

• Browser-based development.
• AI-assisted application creation.
• Integrated execution environment.
• Collaboration features.
• Deployment options.

It’s particularly useful when you want to experiment with an idea without spending too much time on local setup.

However, a generated prototype isn’t automatically a secure or production-ready application.

Best for: Beginners, rapid prototyping, and developers who want an integrated online environment.

Website: https://replit.com

6. Aider AI Pair Programming From Your Terminal

<AsyncImage query=” Aider AI pair programming terminal git code editing interface” aspectRatio=”16:9" />

If you prefer working in the terminal rather than switching between graphical interfaces, <Entity value=” Aider” category=” software” disambig=” Open-source AI pair programming tool”/> is worth exploring.

Aider connects AI models to your local codebase and helps you make changes through conversational instructions.

For example, you could ask:

“Refactor this Python function to improve readability. Keep the existing behavior and add tests for the edge cases.”

Aider can edit relevant files and work with Git, making it easier to review and manage changes.

Why it’s interesting:

• Terminal-based workflow.
• Works with supported AI models.
• Git integration.
• Multi-file editing.
• Useful for refactoring and debugging.

One advantage is that you can incorporate it into a workflow that already relies heavily on Git and command-line tools.

Best for: Developers comfortable with terminals who want AI-assisted pair programming.

Website: https://aider.chat

7. Continue Bring AI Assistance Into Your Existing IDE

<AsyncImage query=” Continue.dev AI coding assistant VS Code IDE interface” aspectRatio=”16:9" />

Not everyone wants to switch code editors just to use AI.

<Entity value=”Continue” category=”software” disambig=”Open-source AI coding assistant for developer IDEs”/> focuses on bringing AI assistance into supported development environments.

It offers an extensible approach to AI-assisted coding, including configurable models and development workflows.

You can use it to:

• Ask questions about your code.
• Generate and edit functions.
• Understand unfamiliar code.
• Work with different supported AI models.
• Customize your development setup.

For example, you might configure Continue to use a model suited to your coding tasks and another for faster, simpler explanations.

This flexibility is useful when you don’t want to depend entirely on one AI provider.

Best for: Developers who want an extensible AI coding assistant inside their existing IDE.

Website: https://www.continue.dev

The Other 3 AI Coding Tools Worth Knowing

These tools didn’t make my main seven, but they solve specific problems and deserve attention.

<box gap={3}> <row align=start gap={3}> <AsyncImage query=”Amazon Q Developer code assistant logo interface” aspectRatio=”1:1" maxWidth=”76px”/> <box flex=”1" gap={1}> **8. Amazon Q Developer**

An AI assistant for software development, with capabilities that include code suggestions, explanations, and AWS-related development assistance.
Website: https://aws.amazon.com/q/developer/
</box>

</row> <divider color=”subtle”/> <row align=start gap={3}> <AsyncImage query=”Google Gemini Code Assist logo” aspectRatio=”1:1" maxWidth=”76px”/> <box flex=”1" gap={1}> **9. Gemini Code Assist**

Google's AI coding assistant for code completion, generation, explanations, and development support across supported IDEs.

  Website: https://codeassist.google/
</box>

</row> <divider color=”subtle”/> <row align=start gap={3}> <AsyncImage query=”Sourcegraph Cody AI coding assistant logo” aspectRatio=”1:1" maxWidth=”76px”/> <box flex=”1" gap={1}> **10. Sourcegraph Cody**

An AI coding assistant focused on helping developers understand and work with codebases, particularly useful for navigating larger projects.
Website: https://sourcegraph.com/
</box>

</row> </box>

Which AI Coding Tool Should You Choose?

Choosing a tool based on popularity alone is a mistake.

Your development workflow matters more than the number of features a product advertises.

Your goalTool to exploreEveryday AI-assisted codingCursorMulti-step coding tasksClaude CodeInline code suggestionsGitHub CopilotAI-first development environmentWindsurfBuilding application prototypesReplitTerminal-based pair programmingAiderCustomizable IDE assistanceContinueAWS developmentAmazon Q DeveloperGoogle ecosystem developmentGemini Code AssistExploring large codebasesSourcegraph Cody

How to Get Real Value From AI Coding Tools

The biggest mistake developers make is asking AI to build an entire application without understanding what they’re creating.

A better approach is to use AI as a development partner.

Here is a workflow worth trying:

Step 1: Explain the problem.

Describe what you want to build, who will use it, and what problem it solves.

Step 2: Ask for a project structure.

Before generating code, ask the assistant to suggest folders, modules, dependencies, and the overall architecture.

Step 3: Build one feature at a time.

Start with authentication, a database model, an API endpoint, or a dashboard component.

Step 4: Generate tests.

Ask the AI to create tests for normal inputs, invalid inputs, and edge cases.

Step 5: Review every change.

Check the generated code, dependencies, permissions, and security implications.

Step 6: Run the application yourself.

Never assume that code is correct just because an AI tool says the task is complete.

Step 7: Use Git to track changes.

Commit working versions so you can understand, compare, and reverse changes when necessary.

Final Thoughts

AI coding tools are changing how developers approach software development.

But the biggest advantage doesn’t come from finding one tool that writes everything for you.

It comes from understanding which tool is best suited to each stage of the development process.

Use Cursor for everyday coding, explore Claude Code for multi-step tasks, try Aider if you enjoy terminal workflows, and experiment with Replit when you want to turn an idea into a prototype quickly.

You don’t need ten subscriptions or ten different coding assistants.

Choose one, use it on a real project, and learn how to review the code it produces.

The best AI coding tool isn’t the one that writes the most code. It’s the one that helps you build better software while making you a better developer.

I Tried 10 AI Coding Tools. These 7 Actually Impressed Me. was originally published in Artificial Intelligence in Plain English on Medium, where people are continuing the conversation by highlighting and responding to this story.

You can use Python to build websites, develop backend systems, create REST APIs, connect databases, manage user accounts, and power applications that serve thousands of users.

But here’s something many beginners don’t realize: you don’t need to learn an entirely new programming language to start building the backend of a web application.

If you already know Python, two frameworks are worth exploring: FastAPI and Django.

Both help you build web applications, but they approach development differently. Understanding when to use each one can save you a lot of time.

Let’s explore how they work, what you can build with them, and how to get started.

1. What Is Python Web Development?

A web application usually has three major parts:

• Frontend: The interface users interact with, built using technologies such as HTML, CSS, and JavaScript.
• Backend: The server-side logic that processes requests, handles authentication, and performs operations.
• Database: The system that stores information such as user accounts, orders, products, and transactions.

Python frameworks help you build the backend.

For example, imagine creating an online shopping application.

When a customer opens a product page, the frontend sends a request to the backend. The Python application retrieves product information from the database and returns it to the frontend.

The frontend then displays the information to the customer.

This entire process can be managed using Python.

2. FastAPI: Build Modern APIs With Python

FastAPI has become an attractive option for developers who want to build modern APIs with Python.

It is designed around Python type hints and supports asynchronous programming.

One of its biggest advantages is automatic API documentation.

You don’t need to manually create a separate documentation page for every endpoint. FastAPI can generate interactive documentation from your application.

Build Your First API With FastAPI

First, install FastAPI and its development server.

pip install "fastapi[standard]"

Create a file called main.py.

from fastapi import FastAPI
app = FastAPI()
@app.get("/")
def home():
    return {"message": "Welcome to my first API!"}
@app.get("/users/{user_id}")
def get_user(user_id: int):
    return {
        "user_id": user_id,
        "name": "Ali"
    }

Start your application:

fastapi dev main.py

Your application will run locally, usually at:

http://127.0.0.1:8000

Open the interactive documentation at:

http://127.0.0.1:8000/docs

You can test your endpoints directly from the browser.

What Just Happened?

Let’s understand the code.

• FastAPI() creates your application
• @app.get("/") defines an endpoint that responds to GET requests.
• @app.get("/users/{user_id}") creates a route with a dynamic parameter.
• user_id: int tells FastAPI to expect an integer.
• return sends the response as JSON.

That’s it. You’ve built a working API using just a few lines of Python.

Build a More Useful API

Now imagine creating a simple task management application.

Users should be able to add tasks, view them, and mark them as completed.

from fastapi import FastAPI
app = FastAPI()
tasks = []
@app.post("/tasks")
def create_task(task: dict):
    tasks.append(task)
    return {
        "message": "Task created",
        "task": task
    }
@app.get("/tasks")
def get_tasks():
    return tasks

This example stores tasks in memory, so the information disappears when the application restarts. A real application would use a database.

However, it demonstrates how quickly you can create API functionality.

When Should You Use FastAPI?

FastAPI is particularly useful when building:

• REST APIs.
• Backend services for mobile applications.
• AI-powered applications.
• Machine learning model APIs.
• Microservices.
• Data processing services.

If you want to build a Python backend that communicates with a frontend or another application, FastAPI is an excellent starting point.

3. Django: Build Complete Web Applications

FastAPI focuses heavily on API development.

Django takes a more comprehensive approach.

It is a high-level Python web framework that provides many features out of the box.

Instead of installing separate packages for every basic requirement, Django already includes tools for:

• User authentication.
• Database management.
• URL routing.
• Form handling.
• Security protections.
• An administrative dashboard.

Template rendering.

This makes Django particularly useful for applications that need a complete backend structure.

Build Your First Django Project

Start by installing Django.

pip install django

Create a new project:

django-admin startproject myproject

Move into the project directory:

cd myproject

Start the development server:

python manage.py runserver

Open your browser:

http://127.0.0.1:8000/

You should see Django’s default welcome page.

You’ve successfully created your first Django project.

Create Your First Django App

A Django project can contain multiple applications.

For example, an e-commerce project might have separate apps for products, customers, and orders.

Create an application:

python manage.py startapp products

Inside the products application, open views.py.

Add this code:

from django.http import JsonResponse
def product_list(request):
    products = [
        {"id": 1, "name": "Laptop"},
        {"id": 2, "name": "Keyboard"},
        {"id": 3, "name": "Mouse"}
    ]
    return JsonResponse({
        "products": products
    })

Now create a urls.py file inside the products folder.

from django.urls import path
from .views import product_list
urlpatterns = [
    path("products/", product_list)
]

Connect the application URLs to your main project’s urls.py:

from django.contrib import admin
from djangourls import path, incl
urlpatterns = [
    path("admin/", admin.site.urls),
    path("", include("products.urls")),
]

You also need to add "products" to INSTALLED_APPS in your project's settings.py.

Now visit:

http://127.0.0.1:8000/products/

Your browser will display a JSON response containing the products.

This is a simple example, but it demonstrates how Django handles requests and returns information.

When Should You Use Django?

Django is particularly useful for:

E-commerce platforms.

• Content management systems.
• Business management applications.
• Customer portals.
• Booking systems.
• Large database-driven websites.

If you want to build a complete application with authentication, database models, and an administrative interface, Django gives you a strong foundation.

4. FastAPI vs. Django: Which One Should You Learn?

Both frameworks are powerful, but they solve slightly different problems.

FeatureFastAPIDjangoMain focusAPI developmentComplete web applicationsLearning curveRelatively lightweightMore concepts to learn Automatic API documentation Built-in Usually requires additional toolsDatabase toolsChoose your preferred integrationsBuilt-in ORMAuthenticationAdd and configure componentsBuilt-in authentication systemAdmin dashboardNot included by default Built-in Async support Designed with async supportSupports asynchronous views and other async features Best suited forAPIs and backend servicesFull-featured web applications

My Recommendation

If you’re new to Python web development, start with FastAPI.

You can build small APIs, understand HTTP requests, work with JSON, and learn how frontend applications communicate with backend services.

After that, explore Django.

Learning both gives you more flexibility when choosing the right framework for a project.

Remember: neither framework is universally better. The right choice depends on the application you’re building.

5. Connect Your Application to a Database

A web application becomes much more useful when it can store information permanently.

Imagine building a task management application.

You don’t want users to lose their tasks every time the server restarts.

This is where databases come in.

Common database options include:

• SQLite — A lightweight database suitable for learning and smaller applications.
• PostgreSQL — A powerful relational database used in many production systems.
• MySQL — Another widely used relational database.

For example, SQLAlchemy can help you work with relational databases in a FastAPI application.

Django provides its own Object-Relational Mapper (ORM), allowing you to interact with database records using Python classes.

Here’s a simple Django model:

from django.db import models
class Product(models.Model):
    name = models.CharField(max_length=100)
    price = models.DecimalField(
        max_digits=10,
        decimal_places=2
    )
    stock = modelsIntegerField(default=0)
    def __str__(self):
        return self.name

This defines a product with a name, price, and stock quantity.

After creating the model, run:

python manage.py makemigrations
python manage.py migrate

Django creates the corresponding database structure.

Now your application has a foundation for storing real product information.

6. Build These 5 Projects to Practice Web Development

Reading documentation is useful, but building projects is where you actually develop your skills.

Here are five practical ideas.

Project 1: Personal Expense Tracker

<AsyncImage query=”personal expense tracker web dashboard income expense charts interface” aspectRatio=”16:9" />

Create an application where users can record their daily expenses.

Features

• Add and delete transactions.
• Categorize expenses.
• Calculate monthly spending.
• Display expense summaries.
• Store records in a database.

Recommended framework: Django.

This project teaches you database models, forms, authentication, and dashboard development.

Project 2: URL Shortener

<AsyncImage query=”URL shortener web application dashboard interface” aspectRatio=”16:9" />

Build a service that converts long URLs into shorter links.

Features

• Submit a long URL.
• Generate a unique short code.
• Redirect users to the original URL.
• Track the number of clicks.
• Display link statistics.

Recommended framework: FastAPI.

This project helps you understand API endpoints, database operations, and HTTP redirects.

Project 3: AI-Powered PDF Summarizer

<AsyncImage query=”AI PDF document summarizer web application interface” aspectRatio=”16:9" />

Build an application that extracts text from PDF files and generates summaries using an AI model.

Features:

• Upload PDF documents.
• Extract text using PyMuPDF.
• Send extracted content to an AI model.
• Generate summaries.
• Allow users to download results.

Recommended framework: FastAPI.

This is an excellent way to combine Python web development with AI.

Project 4: Inventory Management System

<AsyncImage query=”inventory management software dashboard products stock levels interface” aspectRatio=”16:9" />

Create a system that helps small businesses manage their inventory.

Features:

• Add and update products.
• Track available stock.
• Record incoming and outgoing inventory.
• Generate low-stock alerts.
• Display inventory reports.

Recommended framework: Django.

This project teaches you how to build database-driven business applications.

Project 5: Job Application Tracker

<AsyncImage query=” job application tracking dashboard web app interface” aspectRatio=”16:9" />

Build a dashboard that helps users organize their job applications.

Features:

• Save company names.
• Record application dates.
• Track application status.
• Add interview notes.
• Display application statistics.

Recommended framework: Django.

This is a practical project that demonstrates CRUD operations, user accounts, and dashboard design.

7. Skills You Need Beyond FastAPI and Django

Learning a framework is only one part of becoming a web developer.

To build applications that people can actually use, you should understand the technologies surrounding it.

Skill | Why it matters: HTML and CSS: Build the structure and appearance of web pages. JavaScript: Add interactive frontend functionality. HTTP and REST: Understand communication between clients and servers. SQL: Work with databases. Git and GitHub: Track and manage code changes. Authentication: Protect user accounts and application data. Testing: Find errors before deployment. Deployment: Make applications accessible online

You don’t need to master everything before building your first project.

Learn each skill as your application requires it.

8. A Simple 30-Day Learning Roadmap

If you’re starting with Python and want to move into web development, here’s a practical learning plan.

TimelineWhat to learnWhat to buildDays 1–5HTTP, JSON, APIs, requestsSimple APIDays 6–10FastAPI, routes, parametersTask management APIDays 11–15Database basics and SQLAPI connected to a databaseDays 16–20Authentication and validationUser login systemDays 21–25Django fundamentalsBasic CRUD applicationDays 26–30Testing and deploymentDeploy a complete project

By the end, aim to have at least two working projects on GitHub.

The goal isn’t to become an expert in 30 days. It’s to build enough practical experience to understand how real web applications work.

Final Thoughts

Python web development offers much more than creating simple websites.

With FastAPI, you can build modern APIs that connect applications, AI models, and databases.

With Django, you can develop complete business applications with authentication, database management, and administrative tools.

The best way to learn is to stop treating frameworks as something you only study and start using them to solve actual problems.

Choose one project, build its backend, connect a database, test the endpoints, and deploy it.

Don’t just learn Python. Build something people can actually use with it.

Web Development with Python: Build APIs and Web Applications Using FastAPI or Django was originally published in Level Up Coding on Medium, where people are continuing the conversation by highlighting and responding to this story.

💥 Master AI & Tech Skills
🔥 Up to 50% OFF — Limited-Time Offer
👉 Enroll Now & Start Learning

But there is a difference between knowing Python and understanding what it can actually do.

Many developers spend years using the same familiar features: loops, lists, dictionaries, functions, and classes. Meanwhile, Python has powerful built-in tools that can make code shorter, cleaner, faster to debug, and easier to maintain.

The interesting part? You don’t always need another library to improve your code. Sometimes, the solution is already built into Python.

Here are 10 powerful Python features worth adding to your development toolkit.

1. enumerate() — Stop Managing Indexes Manually

Have you ever written something like this?

names = ["Ali", "Sara", "Ahmed"]
for i in range(len(names)):
    print(i, names[i])

It works, but Python offers a cleaner alternative.

names = ["Ali", "Sara", "Ahmed"]

for index, name in enumerate(names):
    print(index, name)

You get both the index and the value without manually accessing list positions.

You can even choose where counting starts:

for index, name in enumerate(names, start=1):
    print(f"{index}. {name}")

Why it matters: It makes loops easier to read and reduces unnecessary indexing.

2. zip() — Process Multiple Lists Together

Imagine you have two lists: employee names and their salaries.

employees = ["Ali", "Sara", "Ahmed"]
salaries = [50000, 65000, 55000]

Instead of accessing both lists through indexes, use zip():

for employee, salary in zip(employees, salaries):
    print(f"{employee}: Rs. {salary}")

Output:

Ali: Rs. 50000
Sara: Rs. 65000
Ahmed: Rs. 55000

You can also create a dictionary:

employee_data = dict(zip(employees, salaries))
print(employee_data)

One important detail: zip() stops when the shortest iterable ends. If you need to handle unequal lengths, explore itertools.zip_longest().

Why it matters: It simplifies working with related datasets, especially when processing spreadsheets, reports, and records.

3. collections.Counter() — Count Anything Without Writing a Loop

Counting repeated values is a common programming task.

For example, suppose you want to know which products appear most frequently in an order list.

The traditional approach involves creating a dictionary and updating counts manually.

Python already has a specialized tool for this.

from collections import Counter
orders = [
    "Laptop",
    "Mouse",
    "Laptop",
    "Keyboard",
    "Mouse",
    "Laptop"
]
counts = Counter(orders)
print(counts)
print(counts.most_common(2))

Output:

Counter({'Laptop': 3, 'Mouse': 2, 'Keyboard': 1})
[('Laptop', 3), ('Mouse', 2)]

You can also count characters, words, categories, and other hashable values.

Why it matters: It is particularly useful for data analysis, frequency reports, text processing, and inventory summaries.

4. pathlib — Work With File Paths Properly

Many developers still use basic string concatenation to create file paths.

file_path = "reports/" + "sales.xlsx"

This can become inconvenient when working across different operating systems.

Python’s pathlib provides an object-oriented way to manage paths.

from pathlib import Path
folder = Path("reports")
file_path = folder / "sales.xlsx"
print(file_path)
print(file_path.exists())

You can also create directories:

folder.mkdir(parents=True, exist_ok=True)

Find all Excel files:

for file in folder.glob("*.xlsx"):
    print(file.name)

Why it matters: It makes file handling cleaner and more portable, especially in automation projects.

5. defaultdict() — Avoid Repeated Dictionary Checks

Suppose you want to group employees by department.

A normal dictionary requires checking whether a key already exists.

employees = [
    ("Ali", "Finance"),
    ("Sara", "HR"),
    ("Ahmed", "Finance")
]

Using defaultdict, you can simplify the process:

from collections import defaultdict
departments = defaultdict(list)
for name, department in employees:
    departments[department].append(name)
print(dict(departments))

Output:

{
    'Finance': ['Ali', 'Ahmed'],
    'HR': ['Sara']
}

The dictionary automatically creates an empty list whenever a new department appears.

Why it matters: It is useful for grouping records, organizing datasets, building lookup structures, and processing large collections of information.

6. functools.lru_cache() — Stop Repeating Expensive Calculations

Imagine a function that performs the same expensive calculation multiple times.

Why calculate the same result again when you can store it?

Python provides lru_cache for this purpose.

from functools import lru_cache
@lru_cache(maxsize=128)
def fibonacci(n):
    if n < 2:
        return n
    return fibonacci(n - 1) + fibonacci(n - 2)
print(fibonacci(30))

The decorator remembers previous results and reuses them when the same arguments appear again.

You can inspect its cache statistics:

print(fibonacci.cache_info())

Why it matters: Caching can significantly improve repeated calculations and reduce unnecessary work.

One limitation: function arguments must be hashable, and cached results should remain valid for the inputs being reused. If the function depends on changing external data, caching needs extra care.

7. contextlib — Manage Resources Without Messy Cleanup

When working with files, database connections, or other resources, proper cleanup matters.

Python’s with statement makes resource management easier.

You probably already use it with files:

with open("data.txt", "r") as file:
    content = file.read()

But you can create your own context managers using contextlib.

from contextlib import contextmanager
@contextmanager
def managed_resource():
    print("Opening resource")
    try:
        yield
    finally:
        print("Closing resource")
with managed_resource():
    print("Using resource")

Output:

Opening resource
Using resource
Closing resource

The finally block runs when the context exits, including when an exception occurs.

Why it matters: It helps developers manage setup and cleanup consistently without repeating boilerplate code.

8. itertools Handle Iteration More Efficiently

Python loops are useful, but sometimes you need more advanced ways to process sequences.

The itertools module provides tools designed specifically for iteration.

For example, chain() combines multiple iterables:

from itertools import chain
group_a = [1, 2, 3]
group_b = [4, 5, 6]
combined = chain(group_a, group_b)
for item in combined:
    print(item)

You can also use islice() to retrieve a specific portion of an iterable:

from itertools import islice
numbers = range(1000000)
first_five = list(islice(numbers, 5))
print(first_five)

Unlike creating a complete list first, islice() works directly with the iterable.

Why it matters: These tools are valuable when processing large datasets, generating combinations, or working with data streams.

9. dataclasses — Write Cleaner Data Models

Sometimes, you need a class whose main purpose is to store information.

Writing constructors and other repetitive methods manually can make these classes unnecessarily long.

Python’s dataclasses module handles much of that work.

from dataclasses import dataclass
@dataclass
class Employee:
    name: str
    department: str
    salary: int
employee = Employee(
    name="Sara",
    department="Finance",
    salary=65000
)
print(employee)

Python automatically generates useful methods, including an initializer and a readable representation.

You can also create immutable instances:

@dataclass(frozen=True)
class Product:
    name: str
    price: float

With frozen=True, normal attribute reassignment is prevented.

Why it matters: Dataclasses make data-heavy applications easier to structure and maintain.

10. breakpoint() — Debug Code Without Guesswork

Printing variables is one of the oldest debugging techniques.

print(user_data)
print(total_amount)
print(status)

It works, but repeatedly adding and removing print statements gets annoying.

Python provides a built-in debugging shortcut:

def calculate_total(prices):
    total = sum(prices)
breakpoint()
    return total

When execution reaches breakpoint(), Python enters its debugger.

You can inspect variables, execute expressions, and move through the code.

Useful debugger commands include:

• n — Execute the next line.
• s — Step into a function.
• c — Continue execution.
• p variable — Print a variable's value.
• q — Quit the debugger.

Why it matters: Debugging becomes more systematic because you can investigate what your program is doing at a specific point.

Bonus: __slots__ — Control Instance Attributes

This feature is less common in everyday Python code, but it can be useful when creating many instances of a class.

Normally, Python instances commonly store attributes in an instance dictionary.

Using __slots__, you can declare the permitted instance attributes:

class Employee:
    __slots__ = ("name", "department")
def __init__(self, name, department):
        self.name = name
        self.department = department
employee = Employee("Ali", "Finance")

This can reduce per-instance memory usage in suitable classes and prevents adding undeclared attributes.

However, it introduces restrictions and may affect inheritance and other class behavior. Use it when profiling shows a genuine benefit, not just because it looks advanced.

Which Features Should You Learn First?

You don’t need to memorize everything at once. Start with features that solve problems you encounter regularly.

FeatureBest useenumerate()Cleaner loopszip()Combining related datasetsCounter()Counting repeated valuespathlibFile automationdefaultdict()Grouping recordslru_cache()Avoiding repeated calculationscontextlibResource managementitertoolsEfficient iterationdataclassesCleaner data modelsbreakpoint()Debugging__slots__Memory-conscious classes

Final Thoughts

Becoming a better Python developer doesn’t always mean learning a new framework, installing another library, or writing more complicated code.

Sometimes, it means discovering that Python already has a better solution for something you have been doing manually.

Start with three features: pathlib, Counter, and lru_cache. Try them in a real project rather than simply reading their documentation.

Then gradually explore the others.

The goal isn’t to use every Python feature you discover. It’s to recognize the right tool when a problem appears.

Good developers know how to write code. Great developers know when Python has already solved the problem for them.

Thank you for being a part of the community

Before you go:

👉 Be sure to clap and follow the writer ️👏️️

👉 Follow us: Medium

Disclosure: This post includes affiliate and partnership links.

Most Python Developers Ignore These Powerful Features was originally published in CodeToDeploy on Medium, where people are continuing the conversation by highlighting and responding to this story.

You might fix one bug and accidentally introduce two more. A function that worked yesterday might fail after a small update. And manually checking every feature whenever you change something quickly becomes exhausting.

💥 Master AI & Tech Skills
🔥 Up to 50% OFF — Limited-Time Offer
👉 Enroll Now & Start Learning

That’s why automated testing matters.

Python has a powerful testing framework called pytest. It makes writing, running, and maintaining tests much easier without forcing you to write complicated testing code.

But many developers only use its basic features.

There are several pytest features that can make your testing workflow cleaner, faster, and more reliable.

Here are seven worth learning.

1. Parametrize Tests: Multiple Inputs Without Repeating Code

Imagine you have a function that adds two numbers.

You want to test it with several different inputs.

One approach is to write separate tests:

def test_add_positive_numbers():
    assert add(2, 3) == 5
def test_add_negative_numbers():
    assert add(-2, -3) == -5
def test_add_zero():
    assert add(0, 5) == 5

This works, but it creates unnecessary repetition.

pytest provides @pytest.mark.parametrize to test multiple input combinations using one function.

import pytest
def add(a, b):
    return a + b
@pytest.mark.parametrize(
    "a, b, expected",
    [
        (2, 3, 5),
        (-2, -3, -5),
        (0, 5, 5),
        (10, 20, 30)
    ]
)
def test_add(a, b, expected):
    assert add(a, b) == expected

pytest runs the same test with every combination.

Why it’s useful: You can test normal inputs, edge cases, and unusual values without writing separate test functions for each scenario.

This is particularly useful when testing calculations, data transformations, and API validation.

2. Fixtures Reuse Setup Code Across Tests

Some tests require preparation before they can run.

For example, imagine testing a function that processes customer information.

Every test needs the same sample customer data.

You could create the data inside every test, but that becomes repetitive.

Fixtures solve this problem.

import pytest
@pytest.fixture
def customer():
    return {
        "name": "Alex",
        "email": "alex@example.com",
        "age": 25
    }
def test_customer_name(customer):
    assert customer["name"] == "Alex"
def test_customer_email(customer):
    assert customer["email"] == "alex@example.com"
def test_customer_age(customer):
    assert customer["age"] == 25

pytest automatically provides the fixture when a test requests it as an argument.

Fixtures can also prepare database connections, temporary files, test clients, and other resources.

Why it’s useful: Avoid duplicated setup code and keep tests organized.

One particularly useful feature is fixture scope. You can control whether a fixture runs once per test function, class, module, or entire test session.

3. tmp_path Test Files Without Creating Messy Folders

Testing file-related functionality can be annoying.

Suppose your application creates a report and saves it to disk.

You want to verify that the file is generated correctly, but you don’t want every test to leave unnecessary files in your project folder.

pytest provides the built-in tmp_path fixture.

def save_report(path):
    path.write_text("Monthly report completed")
def test_save_report(tmp_path):
    report = tmp_path / "report.txt"
    save_report(report)
    assert report.exists()
    assert report.read_text() == "Monthly report completed"

pytest creates a temporary directory for the test.

You can write files inside it, inspect them, and avoid manually cleaning up your project directory.

Why it’s useful: Perfect for testing file uploads, report generators, document processors, and file automation scripts.

4. monkeypatch Replace Real Dependencies During Testing

Imagine your application retrieves information from an external API.

You want to test your function without making a real network request every time.

You could manually change the function or modify your application code.

But pytest provides monkeypatch, which allows you to temporarily replace attributes, environment variables, and other dependencies.

Consider this example:

import pytest
def get_username():
    return "Real User"
def test_get_username(monkeypatch):
    def fake_username():
        return "Test User"
    monkeypatch.setattr(
        __import__(__name__),
        "get_username",
        fake_username
    )
    assert get_username() == "Test User"

The original function is replaced during the test.

pytest restores the change automatically after the test finishes.

You can also use monkeypatch to modify environment variables:

def test_api_key(monkeypatch):
    monkeypatch.setenv(
        "API_KEY",
        "test-secret"
    import os
    assert os.getenv("API_KEY") == "test-secret"

Why it’s useful: Test code without depending on external services, real credentials, or specific machine configurations.

For more complex applications, dedicated mocking tools such as unittest. mock are also worth learning.

5. pytest.raises()Make Sure Errors Are Handled Correctly

Good testing isn’t only about checking whether code works.

You also need to check whether it fails correctly.

Imagine a function that divides two numbers.

Dividing by zero should raise an error.

def divide(a, b):
    return a / b

You can test the expected exception using pytest.raises().

import pytest
def test_divide_by_zero():
    with pytest.raises(ZeroDivisionError):
        divide(10, 0)

You can even inspect the exception message:

def test_invalid_age():
    with pytest.raises(
        ValueError,
        match="Age cannot be negative"
    ):
        validate_age(-5)

This assumes validate_age() raises a ValueError with that message.

Why it’s useful: Verify error handling, input validation, and unexpected conditions instead of only testing successful scenarios.

6. Markers Organize Tests Into Different Categories

As a project grows, running every test after every small change can become time-consuming.

You might have:

• Fast unit tests.
• Slow integration tests.
• Database tests
• Tests that require external services.

pytest markers let you categorize tests.

For example:

import pytest
@pytest.mark.slow
def test_large_data_processing():
    assert sum(range(100000)) == 4999950000
@pytest.mark.integration
def test_database_connection():
    assert True
def test_basic_calculation():
    assert 2 + 2 == 4

You can run only the slow tests:

pytest -m slow

Or exclude them:

pytest -m "not slow"

For custom markers, register them in your pytest.ini file:

[pytest]
markers =
    slow: tests that take longer to run
    integration: tests involving integrated components

Why it’s useful: Keep large test suites organized and choose which tests to run based on your development workflow.

7. pytest-cov: Find Out Which Code Your Tests Actually Cover

You might have 50 passing tests and still have important parts of your application that nobody has tested.

Passing tests don’t automatically mean your application is thoroughly tested.

Code coverage helps you understand which lines of code were executed during testing.

Install the coverage plugin:

pip install pytest-cov

Run:

pytest --cov=my_project

You can also generate a detailed report:

pytest --cov=my_project --cov-report=term-missing

This shows which lines were not executed during the tests.

For an HTML report:

pytest --cov=my_project --cov-report=html

pytest-cov creates an HTML coverage report that you can open in your browser.

Why it’s useful: Identify untested sections of your application and make more informed decisions about where additional tests are needed.

Remember that high code coverage doesn’t guarantee good tests. A test can execute a line without actually checking whether the behavior is correct.

Bonus: Make pytest Run Automatically

Writing tests is useful, but remembering to run them after every change is another problem.

You can connect pytest to GitHub Actions so your tests run automatically whenever you push code or open a pull request.

Create this file:

.github/workflows/tests.yml

name: Python Tests
push:
  pull_request:
jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout code
        uses: actions/checkout@v4
      - name: Set up Python
        uses: actions/setup-python@v5
        with:
          python-version: "3.12"
      - name: Install dependencies
        run: |
          python -m pip install --upgrade pip
          pip install pytest
          pip install -e .
      - name: Run tests
        run: pytest

This example assumes your project supports installation with pip install -e . and declares its dependencies appropriately.

Now your tests can run automatically whenever code changes are pushed.

You can catch problems before they reach your main branch.

A Practical pytest Project Structure

As your project grows, keeping tests organized becomes important.

A simple structure might look like this:

my_project/
│
├── app/
│   ├── __init__.py
│   ├── calculations.py
│   └── users.py
│
├── tests/
│   ├── conftest.py
│   ├── test_calculations.py
│   └── test_users.py
│
├── pytest.ini
└── pyproject.toml

Keep your application code separate from your test code.

You can place shared fixtures inside conftest.py, making them available to tests in the relevant directory.

Run the complete test suite with:

pytest

That’s all you need to get started.

Which pytest Features Should You Learn First?

FeatureBest forParametrizeTesting multiple inputs Fixtures Reusingsetup codetmp_pathTesting file operationsmonkeypatchReplacing dependenciespytest.raises()Testing expected errors Markers Organizing test suitespytest-covMeasuring code coverage

You don’t need to use every feature in every project.

Start with fixtures and parametrization, then introduce the others when your testing requirements become more complex.

Final Thoughts

Automated testing isn’t just about finding bugs.

It’s about making changes with confidence.

When your tests cover important behavior, you can refactor code, introduce new features, and update dependencies without manually checking everything from scratch.

pytest makes that process much easier.

The best part is that you don’t need a huge testing framework to get started. A few well-written tests can already prevent frustrating mistakes.

Write code that works. Then write tests that make sure it keeps working.

Thank you for being a part of the community

Before you go:

👉 Be sure to clap and follow the writer ️👏️️

👉 Follow us: Medium

Disclosure: This post includes affiliate and partnership links.

7 pytest Features That Make Automated Testing Much Easier was originally published in CodeToDeploy on Medium, where people are continuing the conversation by highlighting and responding to this story.

💥 Master AI & Tech Skills
🔥 Up to 50% OFF — Limited-Time Offer
👉 Enroll Now & Start Learning

But here’s something worth understanding: companies don’t simply need people who know how to use ChatGPT.

They need people who can use AI to solve business problems, automate processes, analyze information, build applications, and make existing systems more efficient.

That’s creating opportunities for people with different backgrounds.

You don’t necessarily need a computer science degree to enter the AI space. Depending on the role, a combination of technical knowledge, business understanding, and practical projects can be a strong starting point.

If you’re preparing for the job market in 2027, these are eight AI skills worth developing.

1. AI Workflow Automation

<badge color=”success”>High practical value</badge>

Businesses perform hundreds of repetitive tasks every day.

Employees process forms, respond to emails, update spreadsheets, organize customer information, and prepare reports.

AI workflow automation connects different applications and reduces the amount of manual work involved.

Imagine a company receiving customer inquiries through its website.

An automated workflow could:

1. Receive a new inquiry.
2. Use AI to understand the message.
3. Categorize it by topic.
4. Add the information to a CRM.
5. Notify the appropriate employee.

Instead of manually processing every inquiry, employees can focus on tasks requiring human judgment.

Tools to learn:

• n8n
• Make
• Zapier
• Python
• APIs

Potential career opportunities:

• AI Automation Specialist
• Workflow Automation Developer
• Business Process Automation Analyst

Portfolio project: Build an automated customer inquiry management system that categorizes messages and records them in a spreadsheet.

2. AI Application Development

Using an AI chatbot is one thing. Building an application powered by AI is another.

Companies increasingly need applications that integrate language models into existing products and workflows.

For example, you could build:

• An AI-powered document assistant.
• A customer support application.
• A product recommendation system.
• An intelligent email summarizer.
• An AI-powered research tool.

Python is a particularly useful starting point.

Tools to learn:

• Python
• OpenAI API
• Anthropic API
• FastAPI
• Streamlit
• Git and GitHub

You should also understand API requests, JSON, authentication, and error handling.

Potential career opportunities:

• AI Application Developer
• Junior AI Engineer
• Python Developer
• AI Software Developer

Portfolio project: Create an application that allows users to upload a PDF and ask questions about its contents.

3. AI Data Analysis

Companies have plenty of data.

The challenge is turning that data into information that supports better decisions.

AI can help analysts clean datasets, identify patterns, summarize results, and communicate findings.

Imagine a retail company with thousands of sales transactions.

An analyst could use Python and AI tools to identify:

• Best-performing products.
• Monthly sales patterns.
• Unusual transactions.
• Customer purchasing trends.
• Areas where revenue is declining.

However, AI-generated insights still need verification. Understanding statistics, business context, and data quality remains essential.

Tools to learn:

• Excel
• SQL
• Python
• Pandas
• Power BI
• AI-assisted data analysis tools

Potential career opportunities:

• Data Analyst
• Business Intelligence Analyst
• AI Data Analyst
• Business Analyst

Portfolio project: Build a sales analysis dashboard that identifies trends and explains important business findings.

4. Retrieval-Augmented Generation (RAG)

Companies have internal information stored across thousands of documents.

Employees may need to search through policies, reports, contracts, product manuals, and other files to find specific answers.

RAG helps AI applications retrieve relevant information from external knowledge sources before generating responses.

For example, an employee could ask:

“What is our company’s refund policy?”

Instead of relying only on a model’s general knowledge, a RAG application searches the company’s approved documents and uses relevant information to answer.

The basic workflow involves:

1. Extracting information from documents.
2. Splitting documents into smaller sections.
3. Creating embeddings.
4. Storing information in a searchable database.
5. Retrieving relevant content.
6. Generating an answer based on that content.

Tools to learn:

• LangChain
• LlamaIndex
• FAISS
• Chroma
• PostgreSQL with pgvector

Potential career opportunities:

• RAG Developer
• AI Application Engineer
• Knowledge Management Specialist
• Generative AI Developer

Portfolio project: Build an internal knowledge assistant that answers questions using a collection of company documents and provides source references.

5. AI Agents and Agentic Workflows

Traditional automation follows predefined instructions.

AI agents can use models and tools to work through more flexible, multi-step tasks.

For example, an AI research assistant could:

1. Receive a research question.
2. Search approved sources.
3. Collect relevant information.
4. Compare findings.
5. Organize the results.
6. Prepare a report for human review.

This is more than generating a response to a single prompt.

It involves planning, tool usage, information retrieval, and managing task execution.

Tools to learn:

• LangGraph
• OpenAI API
• Anthropic API
• LlamaIndex
• Python

Potential career opportunities:

• AI Agent Developer
• AI Automation Engineer
• Generative AI Engineer
• AI Solutions Developer

Portfolio project: Build an AI research assistant that gathers information from approved sources and creates structured reports with citations.

Remember that agents can make mistakes. Learn how to control tool permissions, limit actions, and introduce human approval before consequential operations.

6. AI Testing and Evaluation

One of the biggest challenges with AI applications is reliability.

An AI system might produce a correct answer today and a completely different answer tomorrow.

It might misunderstand a question, invent information, or fail when given an unusual input.

Companies need people who can test these systems before they reach customers.

Learn how to evaluate:

• Accuracy.
• Relevance.
• Consistency.
• Hallucinations.
• Response time.
• Cost.
• Performance across different inputs.

Tools to learn:

• pytest
• DeepEval
• Ragas
• Promptfoo
• GitHub Actions

Potential career opportunities:

• AI Quality Assurance Engineer
• AI Evaluation Specialist
• Software QA Engineer
• AI Testing Engineer

Portfolio project: Create a testing framework that evaluates an AI chatbot using a dataset of questions and expected answers.

7. AI Security and Governance

AI introduces new security and privacy challenges.

An application might expose sensitive information, follow malicious instructions hidden in documents, or allow unauthorized users to access information.

Organizations need to understand these risks before deploying AI systems.

Important topics include:

• Prompt injection.
• Data privacy.
• Secure API key management.
• Access control.
• Sensitive information protection.
• AI output validation.
• Human oversight.
• Responsible AI practices.

Tools and resources to explore:

• OWASP guidance for LLM applications
• Python
• Git
• Security testing tools
• AI governance frameworks

Potential career opportunities:

• AI Security Analyst
• AI Governance Analyst
• Cybersecurity Analyst
• AI Risk and Compliance Specialist

Portfolio project: Perform a security assessment of a sample AI chatbot and document potential vulnerabilities, risks, and recommended controls.

8. AI Product Management

Not every valuable AI career requires writing code all day.

Someone also needs to decide what AI products should be built, which problems they should solve, and whether customers actually need them.

That’s where AI product management comes in.

Imagine a company wants to introduce an AI-powered customer support application.

An AI product manager might:

1. Research customer problems.
2. Identify opportunities for AI.
3. Define product requirements.
4. Coordinate with developers and designers.
5. Evaluate the product’s performance.
6. Collect feedback and prioritize improvements.

The key is understanding both technology and business.

Skills to develop:

• Product research.
• Market analysis.
• Business communication.
• Requirements gathering.
• User experience.
• AI fundamentals.
• Product analytics.

Potential career opportunities:

• AI Product Manager
• Associate Product Manager
• AI Business Analyst
• AI Product Operations Specialist

Portfolio project: Prepare a product proposal for an AI tool that solves a specific problem for small businesses, including its target audience, features, business model, and MVP plan.

Which AI Skill Should You Learn First?

Not every career requires the same technical background.

Your starting point should depend on the kind of work you enjoy.

If you enjoy…Start with…Automating repetitive work AI workflow automation; Building software; AI application development Working with numbers AI data analysis; Working with documents RAG Solving complex technical problems: AI agents; Finding errors and improving qualityAI testingSecurity and risk managementAI securityBusiness strategy and planningAI product management

A Practical 90-Day AI Learning Roadmap

You don’t need to master all eight skills in three months.

Instead, choose one primary direction and build a project around it.

<box border radius=”lg” gap={3} padding={3}>
**Month 1 — Build your foundation**

• Learn basic AI concepts.
• Understand how AI APIs work.
• Practice Python or a no-code automation platform.
• Explore real business use cases.

<divider color=”subtle”/>
**Month 2 — Develop a practical skill**

• Choose one specialization.
• Follow a structured learning path.
• Build a small working application or workflow.
• Test it with different inputs.

<divider color=”subtle”/>
**Month 3 — Build your portfolio**

• Complete one useful project.
• Document the problem and your solution.
• Upload your code or project documentation.
• Create a short demonstration.

What Employers Actually Want to See

Knowing the names of AI tools is not enough.

A certificate might show that you completed a course, but a working project demonstrates that you can apply what you learned.

For every project, explain four things:

Question: What to demonstrate: What problem did you identify? A real user or business problem. What did you build? A working AI-powered solution. How does it work?Tools, workflow, and technical approach. What value does it provide? Time saved, errors reduced, or better decisions

You don’t need ten projects.

Two or three well-documented projects that solve specific problems can be more convincing than a portfolio full of unfinished experiments.

Final Thoughts

AI is creating opportunities across software development, data analysis, automation, cybersecurity, and business management.

But learning every new AI tool is not a career strategy.

Choose a direction. Understand the underlying skills. Build something useful. Learn how to evaluate your work.

And don’t ignore the skills that make you valuable beyond AI: communication, critical thinking, problem-solving, and business understanding.

The goal for 2027 shouldn’t be to become someone who simply knows how to use AI. It should be to become someone who knows how to use AI to solve problems that matter.

Thank you for being a part of the community

Before you go:

👉 Be sure to clap and follow the writer ️👏️️

👉 Follow us: Medium

Disclosure: This post includes affiliate and partnership links.

These 8 AI Skills Could Open New Career Opportunities in 2027 was originally published in CodeToDeploy on Medium, where people are continuing the conversation by highlighting and responding to this story.

People were sharing prompt templates, selling prompt packs, and teaching others how to get better answers from ChatGPT.

💥 Master AI & Tech Skills
🔥 Up to 50% OFF — Limited-Time Offer
👉 Enroll Now & Start Learning

But AI is moving quickly.

Today’s tools can understand longer instructions, work with files, use external tools, write code, and complete multi-step tasks. Simply knowing how to phrase a question is becoming less impressive.

That doesn’t mean prompting is useless. It means prompting alone is no longer enough.

The next advantage belongs to people who understand how to build with AI, connect it to real workflows, evaluate its output, and solve problems that businesses actually have.

If I were preparing for the AI job market before 2027, these are the 10 skills I would prioritize.

1. AI Workflow Automation

One of the biggest opportunities in AI is connecting different tools so that work happens automatically.

Imagine a business receiving 100 customer inquiries every day.

Someone has to read each message, identify the customer’s problem, categorize it, and send it to the right department.

An AI-powered workflow can handle much of this process.

For example:

1. A customer submits a form.
2. AI reads the message.
3. The system identifies its category.
4. The inquiry is added to a spreadsheet or CRM.
5. The appropriate team receives a notification.

Tools worth exploring:

• n8n: Build visual automation workflows.
• Make: Connect applications and automate processes.
• Zapier: Automate tasks across business applications.
• Python: Build custom automation logic.

The important skill isn’t learning every automation platform.

It’s learning how to identify repetitive business processes and turn them into reliable workflows.

2. Building AI Agents

Chatbots respond to questions.

AI agents can go further by using tools, retrieving information, and performing multi-step tasks within defined permissions.

For example, imagine an AI research assistant that can:

• Search approved information sources.
• Extract relevant details.
• Compare findings.
• Organize results.
• Generate a structured report.

Instead of giving you one answer, it works through a sequence of tasks.

Technologies worth learning:

• OpenAI API
• Anthropic API
• LangGraph
• LlamaIndex

Start with a simple agent that performs one useful task. Then gradually introduce tool calling, memory, and workflow control.

One important distinction: an agent that can perform actions also needs boundaries. You should understand permissions, human approval, and error handling before allowing it to interact with important systems.

3. Python for AI Development

Python remains one of the most useful languages for working with AI.

You don’t need to become a machine learning researcher to benefit from it.

Learn how to use Python to:

• Connect to AI APIs.
• Process documents
• Clean datasets.
• Automate repetitive tasks.
• Build AI-powered applications.
• Integrate different services.

A basic example using an AI API looks like this:

from openai import OpenAI
client = OpenAI()
response = client..responses create (
    model="YOUR_AVAILABLE_MODEL",
    input="Explain how an AI agent works in simple terms."
)
print(response.output_text)

This small example demonstrates an important capability: connecting your Python application to an AI model.

Once you understand APIs, you can build much more useful applications around them.

My recommendation: Learn Python fundamentals, functions, APIs, JSON, error handling, and asynchronous programming before jumping into complex AI frameworks.

4. Retrieval-Augmented Generation (RAG)

AI models don’t automatically know everything about a company’s internal documents.

Imagine a company with hundreds of PDFs containing policies, product details, financial procedures, and employee guidelines.

Employees need answers based on those documents.

This is where Retrieval-Augmented Generation (RAG) becomes useful.

RAG allows an AI application to retrieve relevant information from an external knowledge source before generating an answer.

A simplified workflow looks like this:

1. Upload documents.
2. Extract their text.
3. Split the text into smaller sections.
4. Convert sections into embeddings.
5. Store those embeddings in a searchable database.
6. Retrieve relevant sections when someone asks a question.
7. Give the retrieved information to an AI model.

Technologies worth exploring:

• LangChain
• LlamaIndex
• FAISS
• Chroma
• PostgreSQL with pgvector

A beginner-friendly project would be a PDF question-answering application.

Upload a document, ask a question, and receive an answer supported by relevant passages.

This is much more practical than building another generic chatbot.

5. AI Evaluation and Testing

Here’s something people often overlook:

An AI application that produces an impressive answer isn’t necessarily a reliable application.

AI can hallucinate, misunderstand instructions, produce inconsistent results, and fail on unusual inputs.

Businesses need people who can determine whether an AI system actually works.

Learn how to evaluate:

• Accuracy.
• Relevance.
• Consistency.
• Hallucination rates.
• Response time.
• Cost per request.
• Performance across different inputs.

Useful tools include:

• DeepEval
• Ragas
• Promptfoo
• pytest

For example, you could create a small test dataset containing 50 questions and expected answers.

Then evaluate your AI application’s responses against those expectations.

This skill becomes particularly valuable when AI moves from experimentation into real business operations.

6. Working With AI APIs

Using ChatGPT through its website is different from integrating an AI model into software.

APIs allow developers to connect AI capabilities directly to their own applications.

For example, a company might use an AI API to:

• Summarize customer feedback.
• Classify support tickets.
• Extract information from invoices.
• Generate product descriptions.
• Analyze survey responses.

Learn these concepts:

• API requests and responses.
• Authentication.
• JSON.
• Rate limits.
• Error handling.
• Token usage.
• Structured outputs.

A particularly useful skill is structured output.

Instead of asking an AI model to return a paragraph, you can request information in a defined format that your application can process.

For example:

{
  "customer_name": "Ali",
  "category": "Billing",
  "priority": "High",
  "requires_follow_up": true
}

This makes it easier to connect AI with databases, dashboards, and automation systems.

7. AI-Assisted Data Analysis

Businesses collect enormous amounts of data.

But raw data doesn’t automatically create useful decisions.

Someone still needs to clean it, understand it, identify patterns, and communicate the findings.

AI can assist with several parts of this process.

For example, imagine receiving a spreadsheet containing 10,000 sales transactions.

You could use Python and AI to:

1. Identify missing values.
2. Detect duplicate records.
3. Summarize sales performance.
4. Identify unusual patterns.
5. Generate visualizations.
6. Explain important findings.

Tools worth learning:

• Python
• Panda
• SQL
• Power BI
• ChatGPT for data analysis

The most important part is understanding the data yourself.

AI can generate a chart or suggest an explanation, but you need to verify whether its conclusions make sense.

8. AI Security and Responsible AI

As companies introduce AI into their operations, security becomes increasingly important.

An AI system can expose sensitive information, follow malicious instructions hidden in documents, or perform actions beyond its intended permissions.

Learn about:

• Prompt injection.
• Data privacy.
• Secure API key management.
• Access controls.
• Sensitive information handling.
• Model output validation.
• Human approval for high-impact actions.

For example, imagine an AI assistant connected to a company’s internal documents.

If it has unrestricted access, a poorly designed system might expose information to users who shouldn’t see it.

Security needs to be considered from the beginning, not added after deployment.

Useful areas to explore include OWASP’s guidance on Large Language Model applications and secure software development practices.

9. Building and Deploying AI Applications

A project that only works on your laptop is a good starting point.

But a project that other people can actually use demonstrates a different level of ability.

Learn how to turn AI experiments into working applications.

A practical technology stack could include:

TechnologyPurposePythonApplication logicFastAPI Build API endpoints Streamlit Create simple interfaces PostgreSQL Store application dataDockerPackage applicationsGitHubManage and share code

For example, you could build an AI-powered document assistant.

A user uploads a PDF, asks questions, and receives answers based on the document.

Then deploy it so other people can test it.

You don’t need a complicated interface. A reliable application that solves one real problem is a stronger portfolio project than ten unfinished experiments.

10. AI Product Thinking

This might be the most underrated skill on the list.

You can understand Python, use AI APIs, and build agents.

But can you identify a problem worth solving?

That’s where product thinking comes in.

Imagine two developers:

Developer A builds another chatbot that answers general questions.

Developer B builds an application that helps small businesses organize customer inquiries, identify urgent complaints, and track unresolved issues.

Both use AI.

But the second developer has identified a specific audience and a practical problem.

Learn how to:

• Identify repetitive problems.
• Understand customer needs.
• Research existing alternatives.
• Define a specific target audience.
• Build a minimum viable product (MVP).
• Collect user feedback.
• Improve the product based on actual usage.

AI development isn’t just about making technology work.

It’s about making technology useful.

The AI Skills I Would Learn First

You don’t need to master all ten skills simultaneously.

Some skills naturally build on others.

Here’s a practical learning sequence:

StageSkillsSuggested focus1Python and APIs Build a foundation2Workflow automationConnect different tools3RAG and AI agents Build useful AI systems4Evaluation and security Make systems reliable5DeploymentTurn projects into applications6Product thinkingSolve real problems

Three Projects That Can Make Your Portfolio Stronger

Instead of collecting certificates without building anything, create projects that demonstrate what you can actually do.

1. AI Invoice Information Extractor

<badge color=”success”>Beginner-friendly</badge>

Build a tool that accepts an invoice PDF and extracts:

• Invoice number.
• Customer name.
• Invoice date.
• Total amount.
• Tax amount.

Use Python, PyMuPDF, and an AI API. Add validation so the application doesn’t blindly trust extracted figures.

2. AI Knowledge Assistant

<badge color=”info”>Intermediate</badge>

Create an application where users upload documents and ask questions about their contents.

Use RAG, embeddings, a vector database, and a simple interface.

3. AI Customer Support Automation

<badge color=”discovery”>Advanced</badge>

Build a workflow that reads incoming customer messages, categorizes them, assigns priority, and prepares suggested responses.

Use Python or n8n, an AI API, and a spreadsheet or database.

These projects demonstrate practical skills rather than just familiarity with AI terminology.

Final Thoughts

Prompt engineering is still useful. Understanding how to communicate with AI will remain part of working with these systems.

But the bigger opportunity is learning what comes after the prompt.

Learn to connect AI with software. Build workflows. Work with data. Test model outputs. Understand security. Deploy applications. Most importantly, learn to recognize problems that are worth solving.

The people who stand out in the coming years won’t necessarily be those who know the longest list of prompts.

They’ll be the ones who can turn AI capabilities into something people genuinely need.

Don’t spend the next year collecting prompts. Spend it building things.

Thank you for being a part of the community

Before you go:

👉 Be sure to clap and follow the writer ️👏️️

👉 Follow us: Medium

Disclosure: This post includes affiliate and partnership links.

Forget Prompt Engineering. Learn These AI Skills Before 2027 was originally published in CodeToDeploy on Medium, where people are continuing the conversation by highlighting and responding to this story.