Snipps

When developing with Microsoft Foundry, two similar terms can easily cause confusion: Microsoft Foundry SDK and Foundry Tools SDKs. Both help developers integrate AI into applications, but they operate at different levels.

The key difference

The Microsoft Foundry SDK provides access to the broader Foundry platform and its project-level capabilities. Foundry Tools SDKs, on the other hand, are specialized SDKs for individual AI services and capabilities.

Microsoft Foundry SDK

A unified SDK for building applications with Microsoft Foundry and accessing project capabilities such as models, agents, evaluations, and tools.

For example, an application that uses a GPT model together with an AI agent and evaluations would typically use the Microsoft Foundry SDK.

Foundry Tools SDKs

Specialized SDKs for integrating individual Foundry AI services into applications.

For example, an application might use the Speech SDK to convert audio into text or Document Intelligence to extract structured information from documents.

In short

A simple way to remember the distinction is:

Foundry SDK = work with the AI platform
Foundry Tools SDKs = use a specialized AI capability

The two approaches are complementary rather than competing: a solution can use the Foundry SDK for its overall AI architecture while also integrating specialized Foundry Tools where needed.

Duplicate files, forgotten downloads and multiple versions of the same photo can quietly consume a surprising amount of storage. Krokiet provides a simple way to find these files and clean up your computer without manually searching through folders.

What is Krokiet?

Krokiet is the modern graphical interface of the open-source Czkawka project. It runs on Windows, Linux and macOS and is designed to find unnecessary or redundant files.

You can use it to identify:

• Duplicate files by comparing their actual content

• Similar images, even when their size, resolution or format differs

• Large files that consume significant storage

• Empty files and folders

• Broken symbolic links and files with incorrect extensions

How to use it

Select the folders you want to examine and exclude locations that should not be touched. Choose the type of scan and let Krokiet analyze the files.

For duplicates, content-based comparison is especially useful because identical files can have completely different names.

Once the scan is finished, review the results carefully before removing anything. Avoid automatically deleting every detected duplicate: two identical files may intentionally exist in different folders.

Tip: Start with personal folders such as Downloads, Documents or Pictures rather than scanning the entire Windows system drive.

Krokiet / Czkawka on GitHub

AI agents change more than how quickly a task can be completed. They change how work is divided between people and AI. Instead of directing every individual step, you can delegate a defined piece of work—and focus your attention on the decisions that require human judgment.

From prompting to delegating

With a conventional AI assistant, you ask a question, receive an answer, review it, and decide what to ask next. You manage the individual steps.

An AI agent can work differently. You define an outcome and the boundaries within which it may operate. The agent can then determine an approach, perform several actions, and adapt subsequent steps based on what it discovers.

A typical workflow becomes:

Define the work → Agent executes → Human reviews and decides

What should you delegate?

Not every part of work is equally suitable for delegation:

• Scoping: Keep responsibility for defining the actual problem.
• Research: Agents can gather, compare, and organize evidence.
• Analysis: Agents can identify patterns and inconsistencies; humans determine their significance.
• Delivery: Agents can prepare drafts, while humans review and approve them.

A useful principle is to delegate the legwork while retaining the judgment.

Make the handover explicit

A good handover defines five elements:

1. Goal – What outcome should the work support?
2. Evidence – Which sources, data, and tools may be used?
3. Constraints – What must or must not happen?
4. Checkpoints – When should the agent stop for human review?
5. Output criteria – What should the result contain and look like?

Start with low-risk tasks and evaluate the results before expanding the agent's responsibilities. Above all, verify important evidence and conclusions before they influence decisions or reach a client.

AI agents can carry work forward independently—but accountability remains human.

AI governance isn't about slowing innovation—it's about enabling organizations to use AI safely and responsibly. This course explains how to build a practical governance framework that balances business value with risk, using real-world examples rather than theory alone.

Key takeaways:

• Understand why AI requires different governance than traditional IT systems.
• Build risk-based governance by classifying AI use cases into buckets (lightweight, standard, enhanced, critical).
• Define clear roles, ownership, committees, and decision rights for AI initiatives.
• Apply governance throughout the entire AI lifecycle, from development to retirement.
• Manage third-party AI vendors, document decisions, monitor risks, and measure governance effectiveness.
• Continuously improve governance by learning from established frameworks such as the EU AI Act, ISO/IEC 42001, OECD AI Principles, and the NIST AI Risk Management Framework.

The course is especially valuable for architects, IT leaders, governance professionals, and anyone responsible for introducing AI into an organization while maintaining compliance, transparency, and business agility.

Course: Designing Responsible AI Governance Frameworks (Pluralsight)

Creating an AI agent is only the first step. The real challenge is making sure it gives reliable answers in different situations. A structured process of improving and testing helps you build agents you can trust.

Instead of guessing whether your instructions are good enough, use tools that guide you while you build and verify the results afterward. This reduces trial and error and makes improvements easier.

A practical workflow looks like this:

1. Build: Write clear instructions and provide the knowledge your agent needs.
2. Improve: Review suggestions that highlight unclear instructions, missing information, or opportunities to make your agent more effective.
3. Test: Run realistic scenarios to see how your agent responds to different questions and situations.
4. Repeat: Refine your instructions based on the results and test again until the responses are consistent.

This continuous cycle helps you discover issues early, improve answer quality, and gain confidence before others use your agent.

Whether you are creating your very first AI agent or refining an existing one, combining guided improvements with systematic testing leads to better and more reliable results. Small, regular changes often make a much bigger difference than rewriting everything at once.

The goal is simple: don't just build an AI agent—build one that consistently performs the way you expect.

A read-only editor is useful when users should view a template without changing its main structure. But sometimes, selected areas still need to remain editable—for example, a table where users enter prices, dates, or project details.

TinyMCE can support this approach by combining HTML’s contenteditable attribute with predefined CSS classes.

The main idea

Keep the editor content protected, but assign a special class such as editablecontent to tables that users are allowed to modify. Template authors can select this class directly from the TinyMCE table properties dialog.

The table_class_list option defines which table classes appear in that dialog:

tinymce.init({
  selector: "textarea",
  plugins: "table",
  menubar: "table",
  toolbar: "table",

  table_class_list: [
    { title: "None", value: "" },
    { title: "Editable Table", value: "editablecontent" },
    { title: "Other Table Type", value: "other_table_class" }
  ]
});

When the template author chooses Editable Table, TinyMCE adds the following class to the table:

<table class="editablecontent">

Your application can then detect this class and make only that table editable.

Why use predefined classes?

• Template authors do not need to edit HTML.
• Editable areas are clearly controlled.
• The same class can be reused across many templates.
• Other table options, such as border styles, can be added to the same list.

For larger configurations, TinyMCE also supports nested class menus. This helps organize editable states, visual styles, and other table types into separate groups.

Moving from an AI prototype to a production-ready application requires much more than calling an LLM. This course provides a practical introduction to Microsoft Agent Framework (MAF), Microsoft's open-source framework for building structured, scalable, and maintainable AI agents. Using a hands-on dentist appointment booking system, it demonstrates how to design agents that interact with external tools, maintain conversation history, remember user preferences, and execute complex business processes.

The course covers:

• Agent fundamentals: understanding the agentic loop, prompt design, tools, sessions, memory, context providers, and middleware.
• Building real applications: creating agents that search, retrieve, update, and persist data while supporting multi-turn conversations.
• Workflows and orchestration: when to use agents versus workflows, multi-agent architectures, handoff patterns, human-in-the-loop approvals, checkpointing, and durable execution.
• Production practices: choosing appropriate LLMs, monitoring with Application Insights, testing with DevUI, managing configuration, and deploying agents as Azure AI Foundry Hosted Agents.

A recurring theme throughout the course is that an AI agent is essentially a language model equipped with tools to accomplish a goal. Rather than focusing on a single demo, the instructor teaches reusable design patterns that can be applied to customer support, booking systems, research assistants, and many other enterprise AI solutions. By the end, you'll understand not only how to build intelligent agents, but also how to make them reliable, observable, secure, and ready for production.

Course: Building Agents with Microsoft Agent Framework – Pluralsight

Even if an AI understands your request, it may not present the answer in the format you expect. One of the simplest ways to improve the result is to clearly describe the expected output. Instead of letting the AI decide how to present the information, tell it exactly what you want.

Expected output instructions define the structure, length, and presentation of the response. They help make answers more consistent and reduce the amount of editing afterward.

Useful instructions include:

• Give me five bullet points.
• Keep the answer under 100 words.
• Return the information as a table.
• Provide only a checklist.
• Write a step-by-step guide.
• Do not include an introduction.
• End with a short summary.
• Give only the final answer.
• List the advantages and disadvantages.

You can also combine multiple instructions into one prompt.

Example Prompt

Compare three ways to save money on groceries. Present the result as a table with the columns Method, Benefits, Drawbacks, and Best For. Keep each table cell under 20 words. After the table, add three practical tips for getting started. Do not include a general introduction.

By describing the expected output, you give the AI a clear target. This makes the response easier to read, easier to reuse, and much closer to what you need without additional editing.

With several Microsoft Copilot experiences available, it can be difficult to know which one to use. Each is designed for a specific purpose, so choosing the right one helps you work faster, find better information, and get more accurate results.

A simple way to choose is to think about your goal:

• Need to find something? Use Copilot Search.
• Need a quick answer or help writing? Use Copilot Chat.
• Want AI to help complete your current task? Use Copilot Cowork.
• Need AI to manage a larger task in its own workspace? Use Copilot Scout.
• Researching a topic across many sources? Use Copilot Researcher.
• Working with numbers or business data? Use Copilot Analyst.

Understanding these roles makes it easier to select the right Copilot for the job. Instead of relying on a single AI experience for everything, you can choose the one that best matches your task and get more focused, efficient, and reliable results.

You are ready to publish. The article reads well, the presentation is clear, and your message is complete. But instead of finishing, you keep changing small details. Sound familiar?

This is a common productivity trap: endless polishing. After a certain point, extra edits often make very little difference. They take time and energy without noticeably improving the final result.

A better approach is to know when to stop refining and start sharing your work.

How AI can help

If you use an AI writing assistant such as Microsoft Copilot, let it perform the final review instead of repeatedly reading the document yourself. Ask it to:

• Check for clarity
• Suggest small improvements
• Find grammar or spelling issues
• Highlight sentences that could be easier to understand

This gives you a fresh perspective while helping you avoid unnecessary editing.

Remember the goal

The goal is not a perfect document—it is a document that communicates its message clearly. Once the important ideas are easy to understand and obvious mistakes are fixed, additional changes often provide only small benefits.

Learning to recognize when your work is "good enough" helps you save time, reduce mental fatigue, and spend more energy on creating your next great piece of work instead of endlessly refining the last one.

Have you ever received an AI answer that wasn't quite what you wanted? Often, the problem is not the AI—it is that the prompt did not include enough information. Adding a little more context helps the AI understand your request and produce a more useful response.

Before asking your question, provide the key details the AI needs:

• Goal – What do you want to achieve?
• Audience – Who is the content for?
• Format – Article, email, checklist, table, or another format.
• Tone – Friendly, professional, formal, or simple.
• Source material – Include any notes, text, or information the AI should use.

The more relevant information you provide, the fewer assumptions the AI has to make. This usually leads to more accurate answers and reduces the need for follow-up prompts.

Example Prompt

Write a short article about healthy breakfasts for busy parents. Use simple English and a friendly tone. Organize the article with an introduction, three practical tips, and a short conclusion. Keep it between 200 and 250 words. Use only the information provided below.

This prompt clearly defines the goal, audience, tone, format, length, and source material. Because the expectations are clear from the start, the AI is much more likely to produce the desired result on the first try.

A lasting transformation rarely comes from finding the perfect diet or exercise plan. More often, it begins with changing the habits and mindset that determine everyday decisions.

From motivation to identity

After years of unsuccessful attempts to lose weight, one man adopted OMAD (One Meal a Day) and continued it for roughly 900 days. He combined fasting with mostly whole foods and simple exercise such as walking, running, swimming and bodyweight training several times a week.

The most important lesson, however, was not a particular fasting schedule. Motivation helped initiate the change, but discipline, consistency and a new sense of identity helped sustain it. Setbacks still happened; the difference was recognizing them quickly and returning to established habits.

Practical principles include:

• create simple routines you can maintain;

• reduce dependence on willpower and motivation;

• treat setbacks as corrections, not failures;

• build a supportive environment and accountability.

OMAD is not appropriate for everyone, and individual health needs should be considered before adopting restrictive fasting practices.

Original video: I Ate One Meal a Day for 900 Days… It Changed My Life (True Story) (en / 21:36) - Big Leap Theory (YouTube)

Thinking about leaving Google without giving up convenience? Proton offers a privacy-focused ecosystem that covers email, cloud storage, passwords, calendars, VPN, documents, and more—all under one account with end-to-end encryption where possible.

A smooth migration works best in three stages:

• Start with Mail, Calendar & VPN: Import your emails, contacts, and calendar, then secure your internet connection with Proton VPN.
• Move Passwords & Files: Import passwords into Proton Pass, migrate files and photos to Proton Drive, and enable automatic photo backups.
• Finish with Docs & Sheets: Basic document editing and collaboration are available, although some advanced features and bulk imports are still limited.

Helpful features include:

• Email aliases to reduce spam and improve security.
• Built-in password management with two-factor authentication support.
• Secure file sharing with password protection and expiration dates.
• End-to-end encrypted video meetings, cloud storage, and document collaboration.

Before migrating, configure your account recovery options carefully. Because Proton uses strong encryption, losing both your password and recovery methods can permanently lock you out of your data. Overall, Proton provides a strong privacy-focused alternative, although some productivity tools are still catching up with established platforms.

Original video: I Rebuilt My Entire Digital Life on Proton: Full Walkthrough (en / 41:34) - Cloudwards (YouTube)

GitHub Copilot becomes much more effective when it is customized for your project. Rather than relying on one-off prompts, you can combine several reusable building blocks that provide context, standardize outputs, automate repetitive work, and create focused AI interactions.

A well-organized customization strategy typically includes the building blocks:

• Instructions: Define project-wide coding standards, architecture, documentation, and development guidelines.
• Custom Instructions: Add folder- or task-specific rules that extend the general instructions for a particular part of the repository.
• Templates: Provide reusable file structures with placeholders for creating consistent documents and source files.
• Prompts: Automate repetitive, multi-step workflows such as creating new features, documentation, or assignments.
• Chat Modes: Create specialized AI conversations for brainstorming, planning, reviews, or other focused tasks.

How They Work Together

A typical workflow might look like this:

1. Instructions provide the overall project context.
2. Custom Instructions add rules for a specific area of the repository.
3. Templates define the structure of the files to generate.
4. Prompts execute the workflow and create or update the required files.
5. Chat Modes support focused discussions before or during implementation.

Using these building blocks together makes Copilot more predictable, produces more consistent results, and reduces the need to repeatedly explain your project's standards and workflows.

Instead of helping you one prompt at a time, GitHub Copilot Coding Agent works like an autonomous developer. You assign it a GitHub issue, and it independently implements the requested changes while you continue working on other tasks.

How does it work?

1. Assign a GitHub issue to Copilot.
2. The Coding Agent creates its own branch and starts a secure GitHub Actions environment.
3. It analyzes the repository, writes the required code, runs tests and validation, and commits its progress.
4. When finished, it opens a draft pull request containing the proposed solution, implementation details, and a summary of the changes.
5. You review the code, provide feedback if needed, and decide whether to merge the pull request.

What can it do?

The Coding Agent is well suited for:

• Implementing new features
• Fixing bugs
• Refactoring existing code
• Adding or updating tests
• Improving documentation
• Performing routine maintenance tasks

Why use it?

Unlike Agent Mode, which works interactively inside your IDE, the Coding Agent runs asynchronously on GitHub. It can continue working in the background while you focus on other development tasks. Because every change is delivered through a standard pull request, your existing review process, branch protections, and approval workflow remain unchanged. When combined with Model Context Protocol (MCP), the Coding Agent can also use project-specific tools and external data sources to produce more accurate, context-aware solutions.

GitHub Copilot can do more than answer general questions. With custom chat modes, you can create specialized AI experiences that guide conversations toward a specific goal. Rather than relying on a generic assistant, a chat mode defines how Copilot should respond, what tools it may use, and which rules it should follow. This makes conversations more consistent and helps the AI stay focused on the task at hand.

Chat modes are ideal for activities such as brainstorming new features, reviewing architecture, planning documentation, or coaching developers. Instead of repeatedly explaining how you want Copilot to behave, you define the behavior once and reuse it whenever needed.

How to create a custom chat mode

1. Create a .github/chatmodes directory if it does not already exist.
2. Add a new file ending with .chatmode.md.
3. Define the chat mode's metadata, including its description and available tools.
4. Describe the response structure you expect Copilot to follow.
5. Add clear rules that limit the scope and style of the conversation.
6. Save the file and select the chat mode from the Copilot Chat interface.

Example

---
description: Brainstorm ideas for new learning assignments
tools:
  - codebase
---

# Response Format

For every response:

1. Summarize the current project or codebase.
2. Suggest 3–5 new ideas.
3. Explain why each idea is valuable.
4. End with one follow-up question.

# Rules

- Keep responses concise.
- Focus on ideas, not implementation details.
- Build on existing project content.
- Always finish with a question.

Templates are a simple way to standardize files that are created repeatedly. Instead of asking GitHub Copilot to generate content from scratch each time, you provide a predefined file containing the desired structure, headings, placeholders, and optional example content. Copilot can then use this template as the starting point, ensuring that every generated file follows the same layout and includes all required sections.

Templates are especially useful for documentation, assignments, design documents, issue reports, meeting notes, tutorials, and many other project artifacts. By combining templates with reusable prompts and instruction files, you can automate repetitive workflows while maintaining consistent quality across your repository.

How to create a template

1. Create a folder to store reusable templates (for example, templates).
2. Create a Markdown file that contains the standard structure.
3. Replace project-specific content with placeholders.
4. Reference the template from a reusable prompt so Copilot knows when to use it.
5. Update the template whenever your standard format changes.

Example

# assignment-template.md

# {{Assignment Title}}

## Learning Objectives

- Objective 1
- Objective 2

## Prerequisites

- Requirement 1

## Instructions

1. Step one
2. Step two

## Starter Code

```python
# Add your solution here

Many AI coding assistants only know what is included in your prompt or current file. Model Context Protocol (MCP) extends GitHub Copilot by giving it secure access to external tools and project-specific information, making its responses far more relevant and accurate.

What is MCP?

MCP is an open standard that connects AI assistants with repositories, documentation, APIs, databases, issue trackers, CI/CD systems, and other development tools. Instead of manually copying information into a prompt, Copilot can retrieve the context it needs automatically.

How does it work?

• An MCP server exposes tools and data through a standard interface.
• GitHub Copilot discovers these tools and can call them when needed.
• The retrieved information is added to the AI's context before generating a response.
• Developers remain in control and can review or approve actions before they are executed.

What can Copilot do with MCP?

With the appropriate MCP servers, Copilot can:

• Read GitHub issues and pull requests
• Search documentation and codebases
• Query external APIs or internal knowledge bases
• Access CI/CD logs and monitoring data
• Integrate with tools such as Slack, Figma, or custom business systems

By combining MCP with Agent Mode or the Coding Agent, GitHub Copilot becomes a context-aware development partner that can understand your project, use external tools, and automate complex development workflows while keeping developers in control.

Many development activities involve repeating the same sequence of actions. Prompt files allow you to package those steps into reusable workflows that can be launched directly from Copilot Chat.

Instead of writing a long prompt every time, you simply execute the reusable prompt and let Copilot perform the workflow.

What prompt files can do

A reusable prompt can:

• Ask for missing information
• Create folders
• Generate multiple files
• Apply templates
• Update configuration files
• Reference instruction files

How to create a reusable prompt

1. Create a .github/prompts folder.
2. Create a file ending with .prompt.md.
3. Describe the workflow as numbered steps.
4. Reference templates or instruction files when appropriate.
5. Save the file.

Example

# .github/prompts/new-assignment.prompt.md

Create a new assignment.

1. Ask for the assignment topic if none is provided.
2. Create a new folder in `/assignments`.
3. Generate `assignment.md`.
4. Add starter code if required.
5. Update `config.json`.
6. Verify that all generated files are linked correctly.

You can then invoke it from Copilot Chat using:

/new-assignment

If the required information is missing, Copilot asks follow-up questions before completing the remaining steps.

Best practices

• Design prompts around complete workflows.
• Break complex tasks into numbered steps.
• Reference instruction files instead of repeating guidance.
• Keep prompts reusable rather than project-specific.
• Test prompts regularly as your project evolves.

Different folders often require different types of guidance. Documentation, tests, templates, and source code rarely follow identical rules. Custom instruction files allow you to define folder-specific behavior so Copilot adapts automatically depending on where you are working.

When to use custom instructions

Examples include:

• Documentation folders
• Assignment content
• Test projects
• Infrastructure scripts
• Sample applications

How to create custom instructions

1. Create an instruction file in the appropriate location.
2. Describe the expected structure and formatting.
3. Specify any required sections.
4. Define optional content such as starter code or examples.

Example

# assignments.instructions.md

When creating a new assignment:

- Start with a title.
- Add learning objectives.
- Include prerequisites.
- Add step-by-step instructions.
- Finish with review questions.
- Provide starter code when applicable.

Whenever Copilot generates content for assignments, it can follow these requirements automatically.

Best practices

• Keep each instruction focused on one purpose.
• Store instructions close to the content they describe.
• Update them whenever the folder structure changes.
• Avoid duplicating global project rules.

GitHub Copilot has evolved from an AI code completion tool into a comprehensive development assistant. Today it supports the entire software development lifecycle, helping developers write code, review changes, automate tasks, and rapidly prototype new ideas.

Writing Code

• Code Completion (2021) – Provides inline AI code suggestions while you type. Best for: Faster coding and reducing repetitive work.
• Copilot Chat (2023) – Answers coding questions, explains code, generates tests, and assists with debugging. Best for: Learning and problem solving.
• Copilot Edits (2024) – Applies coordinated changes across multiple files from a single prompt. Best for: Refactoring and implementing features.

Code Quality

• Code Review (2024) – Detects bugs, performance issues, and improvement opportunities. Best for: Improving code before human review.
• Pull Request Summaries (2024) – Automatically creates clear summaries of code changes. Best for: Better collaboration and documentation.

AI Agents

• Agent Mode (2025) – Plans, edits, tests, and iterates directly within your IDE. Best for: Interactive, multi-step development tasks.
• Coding Agent (2025) – Works asynchronously on GitHub by completing issues and opening pull requests. Best for: Automating routine development work.

Advanced AI

• Multi-Model Support (2024) – Lets you switch between different AI models to suit each task.
• Model Context Protocol (MCP) (2024) – Connects Copilot to repositories, documentation, APIs, and external tools, enabling richer context and more accurate AI assistance.
• GitHub Spark (2025) – Generates interactive application prototypes from natural-language prompts. Best for: Quickly validating ideas and creating proof-of-concepts.

Together, these capabilities transform GitHub Copilot from a coding assistant into an AI-powered development platform that helps developers build software faster, with greater confidence and less repetitive work.

AI-generated code is most valuable when it follows your project's conventions. Instead of repeating coding rules in every prompt, you can store them in an instruction file. GitHub Copilot automatically uses these instructions when generating code, helping produce more consistent results across the repository.

What instruction files are

Instruction files define general project guidance, such as:

• Coding style
• Naming conventions
• Architecture preferences
• Testing requirements
• Documentation standards

Unlike prompts, instruction files do not perform actions. They simply provide persistent context for Copilot.

How to create an instruction file

1. Create a .github/instructions folder if it does not already exist.
2. Create a Markdown instruction file.
3. Add the development rules you want Copilot to follow.
4. Commit the file with your repository so the whole team benefits.

Example

# .github/instructions/coding.instructions.md

## Coding Standards

- Use C# 13 features where appropriate.
- Prefer dependency injection.
- Write XML documentation for public APIs.
- Use async/await for I/O operations.
- Add unit tests for new functionality.

Once saved, Copilot can use these guidelines whenever it generates code for your project.

Best practices

• Keep instructions concise.
• Separate unrelated topics into multiple files.
• Review them as your project evolves.
• Avoid conflicting rules.

There is no universal platform that fits every AI project. The best solution depends on your technical capabilities, business goals, existing systems, budget, and long-term strategy. In many cases, organizations combine multiple approaches—for example, using cloud services together with open-source frameworks or integrating AI into existing enterprise platforms.

Before selecting a technology, it is worth evaluating not only today's requirements but also how the solution will evolve over time.

Questions to ask

• What business problem should the AI agent solve?
• How much customization is required?
• What technical expertise does the team have?
• Which systems need to be integrated?
• What security and compliance requirements exist?
• How important are speed and long-term maintenance?

Quick comparison

A practical recommendation

Many successful AI solutions combine multiple technologies. For example:

• Use Azure OpenAI, AWS Bedrock, or Vertex AI to access AI models.
• Build business logic with LangGraph, Semantic Kernel, or AutoGen.
• Connect workflows using Power Automate, n8n, or Zapier.
• Integrate with existing enterprise platforms such as Salesforce, SAP, or ServiceNow when business data and workflows already exist.

This layered approach lets you benefit from the strengths of each technology instead of relying on a single platform.

Summary

Choose the platform that best fits your business goals, available skills, and existing technology landscape. The most successful AI projects focus on solving business problems—not on using a particular tool.

GitHub Copilot has evolved from an AI code completion tool into a powerful development assistant. With the introduction of AI development agents, Copilot can now help automate entire development workflows rather than simply suggesting individual lines of code.

Instead of acting as an autocomplete tool, AI agents understand high-level objectives, plan the required steps, modify multiple files, execute tests, review results, and assist with completing development tasks. Developers remain in control, reviewing and approving changes while Copilot handles much of the repetitive implementation work.

What GitHub Copilot Can Do

Modern GitHub Copilot agents can assist with tasks such as:

• Implementing new features
• Fixing bugs and refactoring code
• Writing and improving tests
• Generating or updating documentation
• Reviewing code and suggesting improvements
• Creating commits and pull requests
• Building application prototypes from natural language

Depending on the workflow, these tasks can be performed directly inside the IDE or autonomously in GitHub repositories.

Better Results Through Context

GitHub Copilot becomes significantly more effective when it understands your project. By using repository context, documentation, coding standards, issues, pull requests, and external tools, it can generate more accurate and relevant solutions that fit your existing codebase.

Best Practices

To get the best results, provide clear objectives, supply sufficient context, and always review generated changes before accepting them. Think of GitHub Copilot as a collaborative teammate that accelerates development while leaving architecture, security, and business decisions to the developer.

AI development agents represent the next step in GitHub Copilot's evolution, enabling developers to spend less time on repetitive coding and more time designing, solving problems, and delivering high-quality software.

Open-source frameworks give developers the freedom to build AI agents without being tied to a commercial platform. They provide reusable components for common AI patterns such as agent orchestration, memory, tool calling, and workflow management, while still allowing full control over the implementation.

These frameworks evolve quickly and are often among the first to support new AI capabilities. They are a popular choice for development teams that want maximum flexibility and are comfortable managing their own infrastructure and deployments.

Popular frameworks

• LangGraph
• LangChain
• AutoGen
• CrewAI
• Semantic Kernel
• LlamaIndex

Key advantages

• Highly customizable
• No vendor lock-in
• Large developer communities
• Supports advanced agent architectures
• Easy to combine with custom code

Things to consider

• Requires software development expertise
• Community support instead of guaranteed enterprise support
• Frequent updates may introduce breaking changes
• Security and maintenance remain your responsibility

Ideal use cases

• Multi-agent systems
• Research and experimentation
• Custom AI applications
• Enterprise solutions requiring maximum flexibility
• Teams building reusable AI platforms

Summary

Open-source frameworks provide an excellent balance between flexibility and productivity. They accelerate AI development while allowing developers to keep full control over architecture and implementation.

Cloud providers offer complete ecosystems for building, deploying, and managing AI agents. Instead of assembling individual components yourself, these platforms combine AI models with infrastructure, security, storage, monitoring, and development tools. This allows development teams to focus on building intelligent solutions rather than managing servers and infrastructure.

Cloud platforms are particularly attractive for organizations that already run their applications in the cloud, as they integrate naturally with existing services and can scale from small prototypes to enterprise-wide deployments.

Leading cloud platforms

• Microsoft Azure OpenAI, Azure AI Foundry, Azure AI Search, Azure Functions, Azure Logic Apps
• AWS Bedrock, Amazon SageMaker
• Google Vertex AI, Google AI Studio

Key advantages

• Enterprise-grade security
• Automatic scalability
• Managed AI services
• Built-in monitoring and reliability
• Easy integration with cloud resources

Things to consider

• Ongoing cloud costs
• Learning platform-specific services
• Possible dependency on a single cloud provider

Ideal use cases

• Enterprise AI applications
• Customer-facing AI services
• Large-scale automation
• AI solutions that require high availability
• Organizations already using cloud infrastructure

Summary

Cloud platforms provide a powerful foundation for AI agents by combining managed AI services with secure and scalable infrastructure. They reduce operational effort while making it easier to build production-ready AI solutions.

Not every AI solution requires a team of developers. Low-code and no-code platforms allow users to build AI-powered workflows through visual interfaces instead of writing large amounts of code. By connecting triggers, actions, and AI models, organizations can automate everyday tasks in a fraction of the time needed for traditional development.

These platforms are especially useful for creating internal automations, prototypes, or business processes that integrate multiple applications. While they may not offer the same flexibility as custom development, they provide an excellent balance between speed and functionality.

Popular platforms

• Zapier Agents
• n8n
• Microsoft Power Automate
• Microsoft Power Platform
• Make (formerly Integromat)

Key advantages

• Little or no programming required
• Fast development and deployment
• Hundreds of built-in integrations
• Easy workflow automation
• Suitable for rapid prototyping

Things to consider

• Limited customization for complex scenarios
• Advanced workflows can become difficult to maintain
• Platform capabilities differ

Ideal use cases

• Business process automation
• Connecting multiple applications
• AI assistants for internal teams
• Personal productivity workflows
• Proof-of-concept projects

Summary

Low-code platforms make AI accessible to a much wider audience. They are an excellent choice when speed, simplicity, and integration are more important than complete technical control.

Many organizations already use business platforms that now include built-in AI capabilities. Rather than creating an AI agent from scratch, these platforms allow you to build intelligent assistants directly within existing business applications. This significantly reduces development effort because the agent can immediately access business data, workflows, permissions, and automation features that already exist.

For companies that are heavily invested in a specific business ecosystem, this is often the fastest path to delivering useful AI solutions.

Leading enterprise platforms

• Salesforce Agentforce
• ServiceNow AI Agent
• SAP Joule Agents
• Microsoft Dynamics 365 Copilot
• Oracle AI

Key advantages

• Native integration with business applications
• Enterprise-grade security and governance
• Built-in workflows and automation
• Faster implementation
• Vendor support and maintenance

Things to consider

• Higher licensing costs
• Less architectural flexibility
• Potential vendor lock-in
• Features depend on the platform

Ideal use cases

• Customer service
• IT service management
• HR automation
• Finance operations
• Enterprise workflow automation

Summary

Enterprise AI platforms focus on speed, reliability, and business integration. They are an excellent choice when AI should enhance existing enterprise applications rather than replace them.

Building an AI agent from scratch gives you complete control over how it works. Instead of relying on predefined workflows or platform limitations, you decide how the agent reasons, stores information, communicates with other systems, and interacts with users. Although this approach requires more development effort, it provides the flexibility needed for highly specialized solutions.

For organizations with experienced development teams, custom development is often the preferred choice when existing platforms cannot satisfy business or technical requirements.

Popular technologies

• Python
• C# / .NET
• Java
• JavaScript / TypeScript
• OpenAI SDK
• Anthropic SDK
• Google Gen AI SDK
• Model Context Protocol (MCP)

Why choose custom development?

• Complete architectural freedom
• Unlimited customization
• No vendor lock-in
• Freedom to select models and libraries
• Easy integration with existing systems

Things to consider

• Longer development time
• Requires AI and software engineering expertise
• You are responsible for security, scaling, monitoring, and maintenance

Ideal use cases

• Custom business workflows
• Complex enterprise applications
• Specialized integrations
• Products that require unique AI capabilities

Summary

Custom development delivers the greatest flexibility and control, making it ideal for organizations that have the technical expertise to build and maintain their own AI solutions.