Programming and Software Development
AI-assisted development
AI coding assistants now complete lines, draft whole functions and increasingly carry out multi-step changes on their own. They made plausible code cheap to produce and left correctness exactly as hard to establish as before. This topic treats working with them as part of the craft: framing a task precisely, reviewing generated changes with suspicion, testing them properly and deciding which parts of a codebase must never be handed over.
Why this topic exists: Assistants changed how fast plausible code appears, not what makes it correct; reading, testing and correcting generated code is now part of the craft (GitHub certifies Copilot use and, on its 2026 credentials page, agentic AI development).
Coding assistants now sit in the editor, the terminal and the pull request. They finish the line you are typing, answer questions about a codebase in a chat panel, and in agent mode plan and carry out changes across several files, running commands and tests along the way. All of them rest on large language models, which produce the most likely continuation of the context they are given. That makes them fast and fluent, and it also means fluency is no evidence of correctness.
Plausible is not the same as right
Generated code can call functions that do not exist, import packages nobody published, handle the common case and miss the edge, or quietly weaken a security check. Every change needs the same review you would give a stranger's pull request.
A working loop
- Frame the task. State the goal, the constraints, the files involved and an example of the expected result. This is where prompt engineering earns its name.
- Keep changes small enough to review without losing the thread. An agent that rewrites twenty files hands you a review you will not do properly.
- Read the diff line by line and run it. If you cannot explain a line, do not merge it.
- Test independently. Let the assistant draft tests, but choose the edge cases yourself, since a model tends to test the behaviour it just wrote.
- Check what came along: new dependencies, licence questions, secrets pasted into prompts or files.
GitHub's Copilot exam, GH-300, shows how the vendor itself frames competence here. Its study guide groups the skills into responsible use, the assistant's features in the IDE and command line (including agent mode and the Model Context Protocol), how the tool handles data, prompt and context crafting, productivity uses such as generating tests and refactoring, and privacy controls such as excluding content from the assistant's view. Validating AI output is named as a skill in its own right. For the platform underneath, GitHub Foundations is the entry credential, and Microsoft's free Applied Skills lab on Foundry agents turns the question around: building an agent rather than directing one.
What to keep in human hands
Some code should be written slowly by someone who understands it: authentication and permission checks, cryptography, payment handling, migrations that touch production data, and anything a regulator may ask about. Agentic tools also need boundaries on what they may run, especially in repositories holding credentials. Organisations set these limits through content exclusions and policies; individual developers set them by deciding which tasks to delegate at all.
The beginner's risk is learning to prompt before learning to program. Someone who has never debugged their own loop cannot tell when a generated one is wrong, so use the assistant as a tutor that explains rather than a ghostwriter. GitHub Copilot is the assistant most developers meet first. The skills that keep this work safe live in software testing and software engineering practice; the models themselves are covered under generative AI and LLMs, and the security side under application security.
Next to this topic
- Programming fundamentalsOne language learned properly plus enough of the machine beneath it: variables, control flow, data structures, debugging and reading code (SFIA Programming/software development; MDN's getting-started modules).
- Programming languagesPython, JavaScript, Java, C#, C and C++, Go, TypeScript, Rust, Kotlin, Swift: what each is for and where it is hired, so the first choice is a career decision rather than a syntax preference (Udemy's Programming Languages shelf names the market).
- Web developmentHTML, CSS and JavaScript, then a framework and the browser's APIs: MDN's core and extension modules are the syllabus of the largest development field.
- Back-end development and APIsServers, frameworks, databases behind them and the HTTP and REST contracts between services (MDN server-side modules; DVA-C02; the freeCodeCamp back-end certificate).
- Mobile developmentiOS, Android and the cross-platform frameworks are their own toolchains, stores and review rules (SFIA Systems development; Udemy's Mobile shelf).
- Databases and SQLThe relational model, SQL, schema design and the document and key-value stores next to it: the layer every application and every analyst stands on (SFIA Database design; DP-900 relational concepts).
- Software engineering practiceVersion control, code review, testing habits, architecture, design patterns and clean code: the slow layer hiring quietly filters on (SFIA Systems and software lifecycle engineering; MDN version-control module).
- Software testing and QATesting as a discipline: the ISTQB Foundation syllabus v4.0.1 (fundamentals, testing through the lifecycle, static testing, analysis and design, managing test activities, tools) plus the automation frameworks (Selenium, Cypress, Playwright).
- DevOps, Git and CI/CDVersion control workflows, pipelines, containers for developers and the culture that joins build and run (AZ-400; GitHub Foundations and Actions; the cloud field owns infrastructure as code and operations).
- Game developmentEngines, graphics, physics and the design loop are a development field with its own tooling and job market (Udemy's Game Development shelf; SFIA Animation development).
- No-code and low-code developmentBuilding software without writing most of it (Bubble, Webflow, Zapier, Make, Airtable) is a recognised route into shipping products; Microsoft's Power Platform is the office-suite version of the same idea.
Concepts to know
Glossary entries with the reason each one matters here.
- LLMs
The model behind every assistant.
- Prompt Engineering
Instructing the assistant is a skill of its own.
- Agentic AI
Coding agents that run tools, not only complete lines.
Certifications that test it
Vendor exams and free certificates; facts, cost and the preparation path are on each page, and the certifications hub has them all.
Tools of the trade
- GitHub Copilot
The assistant most developers meet first.
Frequently asked
- Should beginners use AI coding assistants?
- Yes, carefully. Ask them to explain code, suggest approaches and review what you wrote, and write the first versions of exercises yourself. The aim is to build the judgement that later lets you check generated code quickly.
- Will coding assistants replace developers?
- They are changing where a developer's time goes, towards specifying work precisely, reviewing and testing. Deciding what should be built, and whether what was produced is correct and safe, remains human work, and that is the part employers are paying for.
- What does the GitHub Copilot certification cover?
- According to Microsoft Learn's GH-300 study guide, it covers responsible use, Copilot's features across the editor and command line, data handling, prompt crafting, productivity uses such as test generation, and privacy and content-exclusion settings. It proves familiarity with the tool, not programming ability.
- Is my code sent to the model provider?
- Context from your editor is sent to generate suggestions; what is retained and whether it is used for training depends on the plan and settings. Read your organisation's policy, and use content exclusions for files that must never leave the repository.
Courses in the directory
10 courses are filed here; the top 6 by our ranking, details and the provider link on each course page.
Last reviewed 26 September 2026 · Getting Digital
