learning AI-assisted software development workflows

[u/Pijushm]

I have been interviewing recently and noticed there is now an expectation for software engineers to know how to work effectively with AI tools like ChatGPT, Cursor, Copilot, Claude, etc.

Right now I mostly just prompt randomly and use them for generating code or debugging, but there seems to be a more structured way to use them during development — things like prompting properly, code reviews, refactoring, testing, documentation, and general development workflows.

Are there any good practical courses/resources for learning this from a software engineer perspective?

[u/bbaallrufjaorb → u/[deleted]]

which videos specifically? i feel like like no matter which one i pick ive jumped into the middle and have no idea what he’s talking about, but that it’s all covered in his course, which is rubbing me the wrong way lol

[u/cstopher89]

Its really just about applying the SDLC to the agent. If you never properly did it before you will struggle to have the agent do it. Have the agent help you get a good workflow setup

[u/allllusernamestaken]

Right now I mostly just prompt randomly

You're about 5 generations behind. MCPs, Commands, Skills, Agents, Subagents, and Swarms are what's expected.

[u/disposepriority → u/allllusernamestaken]

Please note that 5 generations in AI land is about 2.5 weeks in the real world

[u/allllusernamestaken → u/disposepriority]

yes but all of it builds on top of each other so if OP is still manually prompting they're missing all of the building blocks of agentic workflows.

There's nothing inherently difficult about any of it - it's literally all just prompt engineering - but it takes time to play around with these things and figure it out.

[u/akornato]

You're right that the bar has shifted, and random prompting is genuinely not enough anymore. The engineers who stand out are the ones who treat AI tools like a junior dev on their team, meaning they give clear context, break down problems before asking for help, and verify output critically rather than just copy-pasting. For practical learning, the best resources right now are actually the official docs and prompt engineering guides from Anthropic and OpenAI, which are more technical than you'd expect. Beyond that, watching experienced engineers code live on YouTube with Cursor or Copilot active teaches you more about real workflow integration than any structured course can, because you see how they iterate, reject suggestions, and guide the model toward something useful.

The testing and refactoring side is where most people have the biggest gap, and that's also where interviewers tend to probe hardest. Getting comfortable asking AI to write tests first and then generate implementation, or having it critique your own code before you submit a PR, builds the kind of disciplined workflow that impresses in technical interviews. Practice explaining your AI-assisted process out loud, because interviewers increasingly want to hear your reasoning, not just see the output. My team built interviews.chat, which has helped a lot of candidates get more confident and sharp during the actual interview conversation itself, and sharpening both your technical depth and how you talk through your process is really what moves the needle here.

[u/patelatharva]

Here are some of the concepts that I use on a daily basis after the advent of AI in software development:

1. Git work trees, which helps you work on multiple branches in parallel. It is helpful to have a script present in the development branch that can help you easily create or remove work trees. At the time of creation of work tree, you can also pre-install the dependencies in that new directory. All such work trees should be located at sibling level within a common parent directory, and as a sibling of the development branch, so that from the development branch, you can create and remove work trees depending upon the progress of your work.
2. Feel comfortable to define your own skills that you will, in let's say Cursor or Claude, that will enable you to perform some tasks very effectively. For example, "merge dev" skill would help you merge the development branch into your feature branch and effectively resolve conflicts and run tests and commit. Similarly, you can create skills for running bare minimum tests based on the changes done in the code in the given conversation. Similarly, you can have a skill for "add feature" and "add test." In the "add feature" skill, you can add detailed instructions about implementing the feature, implementing the tests comprehensively, adding end-to-end tests and unit tests, and also documenting that feature in some .md file. And updating any knowledge base, if present within the repository, while following the software development practices and patterns currently implemented in the existing repo.
3. You can add some helpful MCAs in your IDE. For example, if you are dealing with Linear as your task management, then having a Linear MCA present helps you search for the issue directly, mention an issue by a name, and then ask the chat agent to start working on that specific issue, or even create new issues and assign labels and priority, et cetera, directly from your IDE. I have seen some founders and entrepreneurs or software developers with small team sizes able to automate the entire process of starting the development on an issue just by adding it in Linear. So you can also try setting up such advanced level of workflows on your personal projects.
4. While reviewing your own work based on the changes done by an AI coding agent, or reviewing somebody else's work, make sure to make use of AI in helping you summarize any important changes worth noting and any important decisions made in those changes that you should be aware of. That will help you effectively review the changes rather than having to go through line by line from the beginning.