Rules to Better AI Development

AI coding assistants have become essential tools for developers, but many rely solely on IDE extensions like GitHub Copilot or Cursor. While these are valuable, **AI CLI tools** offer unique advantages that can significantly boost your productivity and code quality.

CLI-based AI tools provide a focused, distraction-free environment with full terminal context, making them ideal for complex tasks, debugging, and working with entire codebases. Anecdotally, developers at SSW have noticed that CLI tools often produce higher-quality, more accurate results than their IDE counterparts - possibly due to better context handling and fewer UI constraints.

<endIntro />

## Why use AI CLI tools?

### ✅ Benefits

* **Better context awareness** - CLI tools can access your entire terminal history, file system, and git state, providing richer context for better suggestions
* **Higher quality output** - SSW developers have observed that CLI tools consistently produce more accurate and contextually appropriate code than IDE extensions
* **Better for complex tasks** - Debugging, refactoring, and multi-file operations often work better in the CLI
* **Universal workflow** - Works across any editor or environment (Vim, VS Code, Notepad++, etc.)
* **Git integration** - Natural integration with git commands and workflows
* **Batch operations** - Easier to automate and script repetitive tasks

### ❌ Trade-offs

* **Learning curve** - Requires comfort with command-line interfaces
* **No inline suggestions** - Unlike IDE extensions, you won't get suggestions as you type
* **Context switching** - Moving between your editor and terminal requires discipline
* **Setup overhead** - May require additional configuration compared to IDE plugins
* **Less visual** - No syntax highlighting or preview in suggestions (though output can be piped to editors)

## Popular AI CLI tools

### 1. **GitHub Copilot CLI**

GitHub's official command-line tool for AI-assisted development. Unsurprisingly, Copilot CLI provides first-class integration with GitHub.

* ✅✅ Delegation - One standout feature not available with other CLI tools is the `/delegate` command which pushes your existing local session to a GitHub coding agent (with context!).
* ✅ Custom agents - You can define custom agents via markdown files with options to define agents at user, repository, and org level within GitHub.
* ❌Flexibility - Copilot CLI locks you into one provider: Copilot. If you're all in on Team GitHub, this is fine. But if you're looking for more options and
less vendor lock-in, you're better off with something like OpenCode.

**Learn more:** [GitHub Copilot CLI Documentation](https://docs.github.com/en/copilot/concepts/agents/about-copilot-cli)

#### Bonus: Sandboxed Copilot CLI
One of SSW's Solution Architects has created a sandboxed version of Copilot CLI, **[Copilot Here](https://github.com/gordonbeeming/copilot_here)**. If you're working
in a high-sec environment or just want added protection around what AI can and cannot access during sessions, we highly recommend checking this out. It spins up within Docker,
is wired to its own reverse-proxy, and provides external controls around the agent itself. 

### 2. **OpenCode**

OpenCode is an **open-source** agent that gives you the most options when it comes to models, providers, and extensibility. While it does provide some free models
OOTB, you are expected to BYO model subscription.
* ✅✅ Flexibility - OpenCode allows you to select from almost any model, as well as select your own **provider**. This kind of agnosticism is a huge win for users,
especially with the AI landscape being as volatile as it is. Being able to learn one CLI, define your own custom agents within it, and then and the models and providers
arbitrarily is a godsend.
* ✅ Custom agents - Custom agents are again defined by markdown files, and while they can be defined and used at a repository level, the general principle of OpenCode is for agents
to be user-level definitions. 
* ✅ Subagent usage - OpenCode is better at reasoning about subagent usage automatically, rather than needing to be explicitly directed to do so. On a long enough agent session, context compacting is a real problem
and can degrade the quality of output, so having enthusiastic subagent usage is a big plus.
* ❌ Integration - Being an independent open-source agent, OOTB integration may not be as robust (or available as quickly) as proprietary tools like Copilot CLI.

**Learn more:** [OpenCode GitHub Repository](https://github.com/anomalyco/opencode)

### 3. **Claude Code (via Anthropic CLI)**

Claude Code is another fan favourite at SSW.

* ✅✅ Custom agents - Claude Code's custom agents are the most configurable we've used. While they provide all the functionality of other offerings (e.g. personas, allowed tools/paths, etc.),
Claude's custom agents also provide dedicated pre and post-use hooks. This is excellent to help with deterministic tool execution, allowing you to guarantee that certain scripts or commands will be run before and after
the agent.
* ✅ Integration - Claude has some interesting integrations that aren't available with other tools OOTB, such as Slack integration.
* ❌Flexibility - Similar to GitHub Copilot, Claude Code locks you in to one provider - in Claude's case; Anthropic.
 

**Learn more:** [Anthropic CLI Documentation](https://github.com/anthropics/anthropic-cli)

### 4. **Other notable tools**

* **Warp AI** - Built into Warp terminal for command suggestions
* **Fig AI** - Autocomplete with AI explanations (acquired by AWS)
* **Shell GPT** - Simple GPT integration for shell commands
* **Codex** - OpenAI's open source CLI tool


## When to use CLI tools vs IDE extensions

<boxEmbed type="good" caption="Use AI CLI tools for:">

* Complex debugging sessions
* Multi-file refactoring
* Git operations and history analysis
* Learning new commands or APIs
* Automation and scripting
* Working across different editors
* Deep code analysis requiring full project context

</boxEmbed>

<boxEmbed type="ok" caption="Use IDE extensions for:">

* Real-time code completion while typing
* Quick inline suggestions
* Single-file editing
* Learning and exploration
* When you need visual feedback immediately

</boxEmbed>

::: info
**Pro tip:** Use both! IDE extensions for real-time suggestions while coding, and CLI tools for complex problem-solving, debugging, and refactoring tasks.
:::

## Getting started

1. **Choose a tool** - Start with GitHub Copilot CLI if you already have a Copilot subscription, or try OpenCode for an open-source option
2. **Install and configure** - Follow the installation instructions for your chosen tool
3. **Start small** - Begin with simple queries like explaining commands or generating shell scripts
4. **Integrate into workflow** - Gradually incorporate CLI AI into your debugging and refactoring workflows
5. **Experiment** - Try different tools to find what works best for your workflow

## Best practices

* **Provide context** - The more information you give (file paths, error messages, what you've tried), the better the results
* **Iterate** - CLI tools work best in a conversational workflow—refine your prompts based on responses
* **Review output** - Always review and understand generated code before using it
* **Combine with version control** - Use git to track AI-generated changes and easily revert if needed
* **Use for learning** - Ask CLI tools to explain their suggestions to deepen your understanding
* **Subagent switching** - Get comfortable with switching between specific subagents like `Plan` and `Build`

---

By incorporating AI CLI tools into your workflow alongside IDE extensions, you can leverage the strengths of both approaches for maximum productivity and code quality.

"Vibe coding" is a trend that has taken the software development world by storm recently. It means developing via a coding agent, and never even looking at - let alone editing - the code. It has also become synonymous with low-quality code 👎.

When writing code as a professional developer, "vibe coding" may make it easy to get a solution up and running without worrying about the details, but as soon as you commit it to the repository under your name, it becomes your responsibility, as if you had written it yourself.

Vibe coding empowers non-developers to build software using AI agents. However, without proper foundation and structure, vibe coding can result in unmaintainable code that fails "the bus test" – meaning if you were hit by a bus tomorrow, no one else could understand or maintain your code.

GitHub Copilot CLI is incredibly powerful, but giving AI deep access to your terminal and file system can be concerning. When you use features like --allow-all-tools - which approves all actions - Copilot can execute commands on your behalf, which means one wrong suggestion could have serious consequences.

Running Copilot CLI in a secure Docker container provides the best of both worlds: powerful AI assistance with strict security boundaries that limit the "blast radius" of any potential mistakes.

Previously, testing desktop features created with AI agents meant checking out a PR branch locally, building the app, and running it manually. Which took time, slowed feedback loops, and encouraged "vibe coding" where changes are shipped without a deep understanding of the code.

By exposing a settings option to switch to specific PR builds, they can be easily installed tested - no local branch juggling or manual builds required.

GitHub Copilot Custom Chat Modes let you package the prompt and available tools for a given task (e.g. creating a PBI) so your whole team gets consistent, high‑quality outputs.

Without a chat mode, individuals might copy/paste prompts . Important acceptance criteria or governance links get lost. New starters don't know the “standard way” and quality varies.

The advent of GPT and LLMs have sent many industries for a loop. If you've been automating tasks with ChatGPT, how can you share the efficiency with others?

GPT is an awesome product that can do a lot out-of-the-box. However, sometimes that out-of-the-box model doesn't do what you need it to do.

In that case, you need to provide the model with more training data, which can be done in a couple of ways.

When you're building a custom AI application using a GPT API you'll probably want the model to respond in a way that fits your application or company. You can achieve this using the system prompt.

AI agents are autonomous entities powered by AI that can perform tasks, make decisions, and collaborate with other agents. Unlike traditional single-prompt LLM interactions, agents act as specialized workers with distinct roles, tools, and objectives.

Repetitive tasks like updating spreadsheets, sending reminders, and syncing data between services are time-consuming and distract your team from higher-value work. Businesses that fail to automate these tasks fall behind.

The goal is to move from humans doing and approving the work, to automation doing and humans approving the work.

There's lots of awesome AI tools being released, but combining these can become very hard as an application scales. Semantic Kernel can solve this problem by orchestrating all our AI services for us.

When using Azure AI services, you often choose between Small Language Models (SLMs) and powerful cloud-based Large Language Models (LLMs), like Azure OpenAI. While Azure OpenAI offer significant capabilities, they can also be expensive. In many cases, SLMs like Phi-3, can perform just as well for certain tasks, making them a more cost-effective solution. Evaluating the performance of SLMs against Azure OpenAI services is essential for balancing cost and performance.

When building an AI-powered solution, developers will inevitably need to choose which Large Language Model (LLM) to use. Many powerful models exist (Llama, GPT, Gemini, Mistral, Grok, DeepSeek, etc.), and they are always changing and subject to varying levels of news and hype.

When choosing one for a project, it can be hard to know which to pick, and if you're making the right choice - being wrong could cost valuable performance and UX points.

Because different LLMs are good at different things, it's essential to test them on your specific use case to find which is the best.

When integrating Azure AI's language models (LLMs) into your application, it’s important to ensure that the responses generated by the LLM are reliable and consistent. However, LLMs are non-deterministic, meaning the same prompt may not always generate the exact same response. This can introduce challenges in maintaining the quality of outputs in production environments. Writing integration tests for the most common LLM prompts helps you identify when model changes or updates could impact your application’s performance.

A chatbot is a computer program that uses artificial intelligence to engage in text or voice conversations with users, often to answer questions, provide assistance, or automate tasks. In the age of generative AI, good chatbots have become a necessary part of the user experience.

✅ Figure: Good example - A nice chatbot in action

Choosing the right chatbot service for your website can be a challenging task. With so many options available it's essential to find the one that best fits your needs and provides a good experience for your users. But what distinguishes a good chatbot from a great one? Here are some factors to consider.

ChatGPT has an awesome API and Azure services that you can easily wire into any app.

The ChatGPT API is a versatile tool capable of far more than just facilitating chat-based conversations. By integrating it into your own applications, it can provide diverse functionalities in various domains. Here are some creative examples of how you might put it to use:

Embedding a user interface (UI) into an AI chat can significantly enhance user interaction, making the chat experience more dynamic and user-friendly. By incorporating UI elements like buttons, forms, and multimedia, you can streamline the conversation flow and improve user engagement.

Comparing and classifying text can be a very time-consuming process, especially when dealing with large volumes of data. However, did you know that you can streamline this process using embeddings?

By leveraging embeddings, you can efficiently compare, categorize, and even cluster text based on their underlying meanings, making your text analysis not only faster but also more accurate and insightful. Whether you're working with simple keyword matching or complex natural language processing tasks, embeddings can revolutionize the way you handle textual data.

Since the release of GitHub Copilot, we have witnessed a dramatic evolution in how developers work within their IDE. It started with a simple AI autocomplete, then a chat function, and now we are in an agentic gold mine. AI has now been integrated deeply into IDEs with products like Visual Studio Code and Cursor, embedding an even deeper level of AI integration within a developer's workflow.