Skip to content
Getting Digital

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

  1. 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.
  2. 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.
  3. Read the diff line by line and run it. If you cannot explain a line, do not merge it.
  4. Test independently. Let the assistant draft tests, but choose the edge cases yourself, since a model tends to test the behaviour it just wrote.
  5. 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

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

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.

Browse the directory shelf

Last reviewed 26 September 2026 · Getting Digital