Wing Tips

Unit Testing with the AI Agent in Wing Pro 12

Fri, 10 Jul 2026 01:00:00 GMT

This Wing Tip covers unit testing with Wing Pro 12's Claude Code agent integration. For the manual workflow -- identifying test files, running and debugging tests yourself, collecting code coverage -- see the parallel Unit Testing Wing Tip.

Setting the Testing Regimen

By default, Wing asks Claude Code to write unit tests for new code and to run those tests successfully before considering its task complete. As long as your code base already has tests, it will do that. If your code base has no existing tests, you may need to nudge it a bit to get it started.

To override this default, set Testing Regimen on the AI Agent tab of Project Properties. Wing compiles your choice into the agent's instructions, so each Claude Code session it starts already knows what you expect.

The regimens trade thoroughness for speed:

None -- The agent never writes or runs tests on its own. Use this if testing is a separate QA or release step.
Minimal (the default) -- Writes tests for new code and runs those new tests before considering the task finished.
Balanced -- Minimal, plus before review or commit it re-runs any stale tests in the directories you changed.
Thorough -- Also runs new and stale tests at task end, and before review or commit it runs every stale test in the project.
Obsessive -- Runs every test in the directories you changed at task end, and the full suite before review or commit.
Custom -- Configure each of the detailed testing regimen axes on its own (when to write tests, what to run before task completion, what to run before review, and what to run before commiting without review)

A test is "stale" when Wing's code-coverage data shows your change touched code that the test depends on. Wing monitors code coverage automatically while the agent runs tests, so the stale-test regimens work without a separate "run everything first" step. Stale detection is a fast heuristic, not a guarantee -- it can miss tests that haven't run recently or that exercise hard-to-trace code -- so whatever regimen you use day to day, plan to run the full suite before a release or a merge to a long-lived branch.

Shown above: The Testing Regimen options on the AI Agent tab of Project Properties, which tell the agent how much to write and run tests on every task.

Iterating on Failures

Once a regimen is set, testing is the agent's job, not yours. When a test fails, the agent reads the failure, refines the code, and re-runs -- and it won't consider a task done until the tests it was asked to run pass.

You generally don't need to step in. If the agent hits something it can't resolve on its own -- a fundamental problem rather than a quick fix -- it stops and reports back, or asks how you'd like to proceed, rather than quietly weakening or skipping a test to force a green run. You can watch the Testing tool update as it works if you like, but the results are also part of the task summary you review before accepting.

For full reference, see the Unit Testing documentation and Wing's Claude Code Agent Integration.

That's it for now! We'll be back soon with more Wing Tips for Wing Python IDE.

As always, please don't hesitate to email support@wingware.com if you run into problems or have any questions.

Fixing Code Warnings with the AI Agent in Wing Pro 12

Fri, 10 Jul 2026 01:00:00 GMT

This Wing Tip looks at fixing code warnings with Wing Pro 12's Claude Code agent integration. For the manual workflow -- disabling warnings, configuring scopes, sharing configurations across projects -- see the parallel Code Warnings Wing Tip.

Code warnings have always told you what might be wrong in your code. With the agent, the next step -- making it right -- is no longer your problem alone.

Fix in the Editor

When Wing flags a warning in the editor (an undefined name, an unresolved import, an unused variable, a syntax issue), the warning tooltip now includes a FIX action. Click FIX and the agent receives the warning text plus the surrounding code as a small, scoped task: fix this warning, in this place.

Most fixes are mechanical and arrive in seconds: imports get added, typos get corrected, dead code gets removed. The change appears in the task review interface (see the agent change review Wing Tip) so you can accept, reject, or refine like any other agent edit.

This is the same FIX action you'll find on a failing unit test in the Testing tool and on an exception in the debugger -- each hands the problem, with its context, to the agent in a single click.

For warnings that don't have an obvious fix -- a possible logic error, say -- the agent will explain what it's doing and ask before making changes that could alter behavior.

If you have external checkers configured (such as Pylint, Ruff, or mypy), their warnings can also be fixed this way.

Shown above: Hovering over a warning indicator in the editor to reveal the FIX action, which sends the warning to the agent for resolution.

Fix Many at Once

To clean up more than one warning in a pass, use Fix Code Warnings in the Code Actions menu at the top right of the editor. It hands the code you point it at -- the selection, the enclosing function or class, or the whole file -- to the agent as a single request: fix the issues that would cause warnings, such as unused imports, undefined names, type errors, and style problems, using its judgment about which are real and which are false positives.

This works from the agent's own read of the code, not the Code Warnings tool, so it doesn't depend on Wing's warnings or any external checkers being configured. As with a single fix, the result comes back through the task review interface for you to accept, reject, or refine.

Shown above: Choosing Fix Code Warnings from the Code Actions menu at the top right of the editor to fix a file's warnings in one pass.

For full reference on Wing's code warnings system, see the Code Warnings documentation. For the agent integration, see Wing's Claude Code Agent Integration.

That's it for now! We'll be back soon with more Wing Tips for Wing Python IDE.

As always, please don't hesitate to email support@wingware.com if you run into problems or have any questions.

Working with Tests and the Claude Code Agent in Wing Pro 12

Fri, 10 Jul 2026 01:00:00 GMT

This Wing Tip continues the series on the Claude Code agent integration in Wing Pro 12. Tests give the agent concrete feedback on whether a change is correct, and give you concrete evidence to review even before reading the diff.

Testing Regimen

Wing provides Claude with a variety of capabilities aimed at making its work more efficient and reducing token consumption. Part of this comes in the form of MCP (Model Context Protocol) servers that it uses to access Wing functionality in ways that make it more efficient.

Another part of Wing's relationship to Claude Code takes the form of guidance that dictates development methodology, and nudges Claude towards using the MCP tools in a way that reduces wall time and token use.

Some of the more dramatic successes seen in our benchmarks were the result of providing Claude with a unit testing capability optimized for token use and guidance on how to do testing as it develops code.

You can control the details of this from the AI Agent in Project Properties. By default -- the Minimal regimen -- Wing asks Claude to write tests for new code and run those new tests before considering a task complete.

You can also request other unit testing modes, each of which varies guidance on when to write tests and when to run them.

Note that if you change the Testing Regimen or its individual parameters, that change will only apply to new Claude Code sessions and not any sessions that are already running.

Running Tests via Wing's Testing Tool

The agent uses the same Testing tool you'd use yourself, configured through the Testing tab in Project Properties (see the Unit Testing Wing Tip). This means:

The agent picks up your project's test file configuration
Failures appear in the Testing tool with the same drill-down as manual runs.
Code coverage data is available to both you and the agent

Results update in the Testing tool as they come in, so you can watch a long suite progress without interrupting the agent.

You don't have to spell all of this out in a prompt every time. The Write Tests item in the Testing menu and editor context menu hands selected code to the agent to write tests for, and when a test fails the Testing tool offers a one-click FIX that sends the failure straight to the agent to diagnose and resolve.

Shown above: Watching the Testing tool update in real time while the agent runs the test suite as part of an in-progress task.

Code Coverage

When Claude Code uses Wing's unit testing MCP, it always runs tests with code coverage enabled. This allows it to run just stale tests after making code changes, a feature that can save huge amounts of time and token usage.

A few things to understand about code coverage:

Code coverage does not mean that code is correct; that depends on whether the unit tests are correct and passing.
Code coverage is not infallible, but it's a great heuristic for reducing development time and token use.

You should still run all your unit tests before releasing your code to production. There is no absolute guarantee that every necessary test run has taken place, if you are relying entirely on code coverage to decide which tests to run.

Using the Tasks Tool with the Claude Code Agent in Wing Pro 12

Fri, 10 Jul 2026 01:00:00 GMT

This Wing Tip takes a look at the Tasks tool in Wing Pro 12, as a way to work with the Claude Code agent.

There are actually two ways to talk to the agent: (1) by typing directly in the embedded Claude Code tool or (2) through the Tasks tool, which runs each request as a queued unit of work. Both feed the same agent process, and both track tasks through their Plan -> Execute -> Review -> History lifecycle in the Tasks tool.

Using the Tasks tool makes sense if you are entering new tasks while all your Claude Code agents are busy. It can also be used as a higher-level "To Do" list, by creating Goals and organizing tasks under them. Tasks may start out as a brief bulleted description, before being fleshed out in preparation to feed them to the AI agent.

Entering and Queueing Requests

If not already visible, you can open the Tasks tool from the Tools menu, navigate to the Plan tab, select Tasks sub-view, and use + New Task to type in a new task. You can also enter tasks under the Goals page of the Plan tab. In fact all tasks belong to a goal, by default the To Do goal.

Tasks entered this way start out in draft mode by default and will not run until you queue them. This is done from the task item's Q menu, or you can queue a whole goal at once from its Q menu. If a goal already has selected a queue, new tasks are immediately moved to that queue.

Once a task is queued, it moves to the Execute tab of the Tasks tool. If the queue is active and has Auto-advance enabled then it will start each queued task automatically. If not, you can use the cog icon to start tasks. If a running task stalls, or you want to stop it early, the Execute tab's per-task actions let you Move to Review to keep what it has done so far, or Reset it back to pending.

Queueing makes it easy to batch related work and walk away. It often makes sense to run a Bug Fixes queue for small fixes as you think of them, while using other queues to manage one or more larger development tasks. You do need to be mindful about multiple Claude Code instances modifying the same code concurrently, but often it's possible to work on different parts of code. You can also ask Claude to constrain its edits to specific files or directories, as part of your requests. Wing does keep track of which files a task actually changes, so you can independently commit work done in different queues.

Even when the Tasks tool isn't visible, the AI agent status area at the right end of the main toolbar shows what the agents are doing at a glance: a running indicator while work is in progress, a count of queues waiting for your input, and a review button that jumps straight to changes ready to look at.

After a task is completed, it transitions to the Review tab, from which you can review and accept or reject edits that were made. That and the History tab will be covered in a future Wing Tip.

Shown above: Queueing three requests in the Tasks tool to run in sequence.

Following Up Within a Task

While a task is running, or after it completes, you can send follow-up requests within the same Claude session. The agent has the full context of what came before, so you don't need to re-explain. Typical follow-ups:

"Did you add unit tests for that?"
"Actually, let's left justify the button instead"
"Also update the user documentation for the features we just added"

Shown above: Typing a follow-up in the Claude Code tool to continue the same session -- here, asking the agent to update the documentation for the change it just made.

Execution Mode and Context

Before you queue tasks, you can use the Q menu to select whether that task will create a new Claude session or reuse an existing session. In many cases, you will want to start a new session for each task, and this tends to save on token use. But if a series of tasks will benefit from the same local context (knowledge of what has been done before) then you should reuse the queue's session.

The most useful options when establishing a new session for a task are:

Plan Mode -- The agent explores the code and writes a plan for the task without making any edits. You review the plan, ask for changes, and only approve it once you're happy with the approach. This is worth using for larger or riskier changes where you want to lock in the design before any code is written, and for pure investigation or diagnosis -- for example tracking down a difficult bug -- since the agent cannot change anything while it works. And because a Plan Mode task makes no edits, it is a safe way to start a task that reads code another task is actively changing, without risk of the two colliding.
Auto Mode -- This enables Claude Code's auto-mode, which uses a classifier to filter which actions to approve automatically and which to present to you for approval. In general, this is the way to go when letting Claude make changes without constant interruption.

Two more modes give you finer control over approvals when you want to watch more closely: Accept Edits pre-approves file edits but still asks before running commands, and Edits Require Approval asks before every edit and command.

When reusing a session for a task, you'll usually just want to select Full Context but Wing also provides Compact Context for cases where context is growing large but contains valuable memories. Note that compacting context itself consumes tokens, so it only makes sense to do in longer-running series of related tasks.

Shown above: Using the Q menu to switch a queued task into plan mode before the agent runs it.

Reviewing and Accepting Agent Changes in Wing Pro 12

Fri, 10 Jul 2026 01:00:00 GMT

This Wing Tip continues the series on the Claude Code agent integration in Wing Pro 12. It covers what happens after the agent finishes a task and before you commit it.

Change Tracking and Review

When a task finishes running in the Claude Code tool, it will transition from the Execute tab of the Tasks tool to the Review tab, where it waits for you to inspect and accept or reject the work that was done.

The Review tab has a section for each queue that is running tasks, and lists all the completed but unreviewed tasks under each queue. Review is done on a per-queue basis. If you accept all changes from a queue, that does not necessarily commit all files. However, granularity of commits is at the file level so you may end up committing changes made in other queues. Wing keeps track of who changed what and will warn in this case.

If a task or queue has made changes, you can click on the diff/merge icons in the Review tab to visit the changed files or view the changes for a file.

In most cases, however, you will use the Start Review or Commit Without Review links on the queue to process all the files changed by that queue at once.

Start Review shows you a diff/merge session in Wing where you can move through all the files and changes, accepting or rejecting each one or making comments on changes using the pencil icon visible in the floating icon set between changes. Pressing the pencil icon in the toolbar lets you make an overall comment and reject the changes. This transitions the task back to Execute and works on changes until it's ready to review again. Review mode is entered again automatically. If you want to accept all the changes instead, press the green check mark icon in the toolbar. Wing will then commit that change set.

Shown above: Reviewing the agent's proposed change side-by-side with the original file and commenting on a particular change.

Commit Without Review just executes the latter part of that process, skipping the review phase. This is appropriate if you have already reviewed the changes or trust that unit tests or other measures have sufficiently vetted the changes in other ways. Looking at diffs is by no means the only way to check Claude Code's work. You can also run tests or ask another Claude instance to review the work. We'll talk more about that in a later Wing Tip.

Commit Modes

Once you actually get to the point of committing, who commits and how is controlled by Commit Mode in the AI Agent tab of Project Properties. There are five choices:

Claude commits only when asked -- The default. Claude never commits on its own; when you start a review or use Commit Without Review, it uses a record of the work done by the relevant tasks to decide on a short commit message and then does the commit. This works well when you have run a series of tasks and don't want a long commit message.

Claude commits after each task -- Claude commits on its own at the end of every completed task, without waiting for you.

Claude commits at its discretion -- Claude commits on its own at the logical stopping points it chooses, deferring when work is incomplete or problems are unresolved.

Wing commits with generated message -- Wing commits immediately, without involving Claude, using a commit message made out of the work summaries for each of the tasks being committed.

Wing presents commit message for review -- Wing builds the commit message from the task summaries and brings it up in Wing's VCS tool, waiting for you to review the message and complete the commit yourself.

History

Once you have committed work done by a task, it transitions to the History tab in the Tasks tool. You can control whether and how history is kept from the History Settings item in the Task tool's Options menu.

From here (and in fact also from the Review tab) you can expand each task to see Claude's responses and any follow-up tasks made in the same session (often as typed directly into the Claude Code tool).

The history for each task also shows the run time and number of tokens consumed by that task. A total for all tasks is at the top of the History tool. This is a good way to estimate how expensive tasks were.

The Resume Session link on tasks lets you resume the Claude Code session, if it is still available, to reinspect what was done.

Introducing the Claude Code Agent in Wing Pro 12

Fri, 10 Jul 2026 01:00:00 GMT

Wing Pro 12 added a deep integration of Claude Code, Anthropic's AI agent. You can use this to queue agent requests, manage their execution, and review and audit each completed task before committing changes. Wing also provides an AI-agent-focused API that Claude uses for code analysis, unit testing, debugging, and version control, in a way that reduces both elapsed time and token use.

This is the first in a series of Wing Tips on working with this new capability.

Shown above: The Tasks tool in use, to queue work for Claude Code in Wing Pro 12.

Setup

To get started:

Install or upgrade to Wing Pro 12.
Get a Claude Code account if you don't already have one (see the Claude Code documentation). Claude Code will prompt you to authenticate the first time you use the agent.
From the Project menu, choose New Project, tick on Set Up for Claude Code, and select an existing or new directory and Python environment. If you already have a Wing project, just open it and choose Set Up for Claude Code from the Project menu.
Set your new or existing project up in a revision control repository. You can use Claude Code without it, but Wing's task review features won't work. Even a local git repository (in same directory as your sources) will work. Ask Claude for help with setup.

Your First Session

Type a request into the Claude Code tool and press Enter -- or add it as a task in the Tasks tool, which queues the work and lets you review it before committing. For example:

"Can you write, run, and fix unit tests for the new user registration dialog?"
"Let's change how this works so it uses a .jsonl file instead."
"Find out why the dashboard sometimes shows yesterday's data, and propose a fix."

The agent reads the relevant files, makes edits, and reports back.

Shown above: Submitting a request from the Tasks tool's Q menu, where you choose the queue and the session mode (such as Plan Mode).

If the result isn't quite right, follow up in the same task -- for example "good, but please add a regression test that would have caught this". The agent has the context of the previous turn and refines accordingly.

Where to Next

AI agents are an astonishing new paradigm for software development. The next several Wing Tips dive more deeply into Wing's new AI agent focused feature set:

The Tasks tool as a way to manage one or more AI agents.
Reviewing and accepting the agent's edits.
Using unit tests to keep code quality high and simplify the review process.
Fixing code warnings with the agent, in place or in bulk.
Best practices for getting reliable results.

Beyond the Tasks tool, Wing also offers one-click FIX actions for exceptions, failing tests, and code warnings, plus right-click Code Actions to explain, review, or optimize code -- see Wing's Claude Code Agent Integration for the full picture.

Best Practices for Working with the Claude Code Agent in Wing Pro 12

Fri, 10 Jul 2026 01:00:00 GMT

This is the closing Wing Tip in the series on Wing Pro 12's Claude Code agent integration. It collects the habits that produce reliable results.

Basic Principles

The fact that AI agents work at all is astonishing, given that the LLMs that underly them are (famously) so good at hallucinating and making other mistakes. The reason they work is that they build in self-checking feedback loops for every level of the software development process.

Your methodology in using them should embrace and build on this basic philosophy of cross-checking everything. There are two parts to this:

Work in an environment where mistakes are contained and correctable.
Recheck and review all work before accepting or shipping it.

AI Safety

AI safety in Claude Code is very very good out of the box. But like people, it can make mistakes and when it does, it makes them very very quickly.

In order for its work to be contained and correctable, you need to set up a reasonably protected environment in a VM, on a dedicated host, or at least in a dedicated account. Don't run Claude Code in an environment where it has access to the keys to your server infrastructure or sensitive data like customer records.

Make sure your environment is backed up automatically, ideally continuously through something like Dropbox or iCloud.
Use revision control with a remote repository that Claude cannot access. Ideally, set up a VCS-only SSH key and do all push or other operations that affect the remote repository manually.

Exactly how you approach this depends on your needs and risk tolerance, and the sensitivity of your work. In fact asking Claude Code for solutions is a great way to find relatively easy ways to set up an environment you are comfortable with.

Treat the Agent Like a Capable Employee

The agent is fast, patient, and capable, but still needs clear instructions and supervision. For the most part, you will no longer be writing code; instead, it's your job to frame tasks, review outcomes, and steer iteration.

Your goal should be to set up a working environment that keeps it honest. That starts with clear, detailed, and specific instructions. It includes unit testing. It may include independent AI agent validation of work for correctness, performance, security, and other metrics.

Cross-Check from Different Angles

A single review pass can miss things on larger changes. That's true whether it's a human working independently, or an AI agent writing the code. Instead, where appropriate, try to run work through a few different lenses:

Behavioral -- does this code really do everything in the spec?
End Cases -- does this code fail to handle end cases that could occur?
Security -- are the security flaws likely to be exploited here?
Performance -- is this code going to be fast enough in production?

Since you can make the AI agent do the assessments, it becomes possible to review code in far more ways and far more deeply than was possible before the advent of AI agents. You can ask the agent to do things that no human employee would put up with:

"Re-read the change you just made and propose the three most likely sources of bugs. Don't fix anything; just list them."

Wing packages several of these lenses as one-click Code Actions in the editor's right-click menu -- Review for Security Risks, Review for Code Quality, and Optimize Code -- each of which frames the request for you.

Review at the Behavior Level

Wing presents agent edits as diffs, which makes it tempting to review line by line. For small changes that's fine. For larger ones:

Read the task summary and the test results first.
Skim the diff for surprises -- new dependencies, new files, scope creep, suspicious patterns.
Spot-check a few hunks to confirm the agent's style.
Trust the rest, contingent on tests and other cross-checks passing.

If you don't trust the test suite enough to do this, strengthen the suite first. The good news is, you just ask Claude Code to do that.

Hopefully you're getting the idea: You're the insufferable manager, and Claude Code provides you with a swarm of willing and extremely capable workers. Your life will never be the same -- in a good way!

When the Agent Gets Stuck

Most of the time you don't need to watch the details of what the agent is doing. But occasionally, especially on a hard bug, Claude Code will start spinning its wheels -- trying one speculative fix after another, fixating on an approach that isn't working, or even brushing off your reports that something is still broken.

When you notice this, step in once or twice with more specific guidance, or point it at the debugger. When you hit an exception yourself, the FIX action in the Exceptions tool hands it to the agent with the full debug context. If that doesn't turn things around, don't keep iterating. It is usually better to start fresh than to try to course-correct an agent that has gone off the rails.

Before you do, look for any unwanted or half-finished code the agent left behind, and either ask it to remove that or revert to your last known-good commit. Then /clear to start a new session, or start a new task from the Tasks tool. A fresh session has no memory of the origin or correctness of uncommitted code, so if you leave a broken attempt in place it may assume that code is intentional and fixate on the same wrong solution. Retrying the fix in Plan Mode can help too, since it makes the agent reason through a new approach before changing anything.

Understanding Context and Token Costs

Claude Code uses both its already-learned knowledge about the software development process, from its original training set, and also facts it has learned about your development environment and project. When you first set up Claude Code in a directory, Wing runs /init to ask Claude to inspect and learn from the files on disk. This gets distilled into the top-level CLAUDE.md, terse documentation that is designed for the AI agent to read automatically when it works on your code subsequently. It will even maintain the document on its own, as code changes.

Wing also writes instructions for Claude, into .claude/CLAUDE.md, so it knows how to use Wing's functionality and an appropriate testing and review methodology.

All of this is combined with input seen in the current Claude Code session into a working context that is essentially a short-term memory. Every time you start a new session, Claude forgets everything, and then reloads some of the memories from the CLAUDE.md files.

This is a simplification of everything Claude Code does, but enough to be able to manage what really matters here -- token use. The more Claude Code has in its memory, and the more it has to read through while doing tasks, the more tokens it uses up out of your allowance. Keeping that under control is an important part of using AI agents.

Fortunately, Wing helps a lot with that. We've designed the Tasks tool and the MCP servers that Claude can use to keep token consumption lower. In our initial benchmarks this often meaningfully reduced the API cost and time to finish a task, though how much depends on the work -- the tools help most when the bottleneck is locating code or runtime state. See the benchmark write-up for the details.

The decision you will have to make is when to either manually type /clear in your Claude Code instance, or when to use the Q menu in the Tasks tool to change the session reuse and run modes (as discussed in previous Wing Tip) to use context when relevant and discard it when not.

Legacy AI Assisted Development in Wing Pro

Wed, 24 Jan 2024 01:00:00 GMT

This article describes Wing 11's single-query AI features (AI Coder). In Wing 12 these are legacy and hidden by default. For Wing 12's AI agent integration with Claude Code, see Wing's Claude Code Agent Integration.

Generative AI is astonishingly capable as a programmer's assistant. As long as you provide it with sufficient context and clear instructions, it can cleanly and correctly execute a wide variety of programming tasks. This Wing Tip introduces Wing Pro's AI assisted software development capabilities.

This guide is for Wing Pro 11's improved AI assisted development UI. If you have Wing Pro 10, you may want to upgrade or instead refer to the integrated documentation in Wing Pro 10's Help menu.

AI Code Suggestion

Here is an example where Wing Pro's AI code suggestion capability is used to write a missing method for an existing class. The AI knows what to add because it can see what precedes and follows the insertion point in the editor. It infers from that context what code you would like it to produce:

Shown above: Typing 'def get_full_name' followed by Ctrl-? to initiate AI suggestion mode. The suggested code is accepted by pressing Enter.

Writing New Code with AI

An even better way to write new code is to use Wing Pro's AI Coder to provide the AI with written instructions. For example, you might ask it to "add client and server classes that expose all the public methods of FileManager to a client process using sockets and JSON":

Shown above: Using the AI Coder tool to request implementation of client/server classes for remote access to an existing class.

The processing time shown in this example is changing for the better as generative AI advances.

Simpler and perhaps more common requests like "write documentation strings for these methods" and "create unit tests for class Person" of course also work. In general, Wing Pro's AI Coder can do any reasonably sized chunk of work for which you can clearly state instructions.

Used correctly, this capability will have a significant impact on your productivity as a programmer. Instead of typing out code manually, your role changes to one of directing an intelligent assistant capable of completing a wide range of programming tasks very quickly. You will still need to review and accept or reject the AI's work. Generative AI can't replace you, but it allows you to concentrate much more on higher-level design and much less on implementation details.

AI Transformation

AI Coder can also be used to request changes to existing code. For example, you might ask it to "convert this threaded implementation to run asynchronously instead":

Shown above: Running the highlighted request in the AI Coder to convert multithreaded code to run asynchronously instead.

Getting Started

To try out AI assisted development in Wing Pro, see the AI Quick Start and the rest of the AI Assisted Development documentation for details on setup, framing requests, and monitoring costs. It takes a bit of time to get started, but it is well worth the effort to incorporate generative AI into your tool chain.

That's it for now! Next time we'll take a look at AI Chat, which allows you to talk about code without directly making changes to it.

As always, please don't hesitate to email support@wingware.com if you run into problems or have any questions.

Legacy AI Chat in Wing Pro

Wed, 24 Jan 2024 01:00:00 GMT

This article describes Wing 11's single-query AI features (AI Chat). In Wing 12 these are legacy and hidden by default. For Wing 12's AI agent integration with Claude Code, see Wing's Claude Code Agent Integration.

This Wing Tip describes how to use the AI Chat tool in Wing Pro to interact with a generative AI assistant, in order to ask questions about existing code or work through the design and implementation of new code.

There are several reasons to use AI Chat rather than AI suggestion and AI Coder, as they were described in the previous Wing Tip:

AI Chat can provide more detailed responses that include both code and explanation of the code.
AI Chat lets you iterate within the context of your previous conversation, making it easier to drill down to the details that you are trying to understand or to refine an implementation.
AI Chat cannot directly modify your code or place code anywhere that it can be executed, which helps to address AI safety concerns.

Asking About Existing Code

Generative AI is particularly good at reading and summarizing large amounts of text or code. You can ask it to focus on specific code or provide it with a number of whole files, and then ask it to explain them to you. It may take some time to process your request, but you'll receive results much faster than trying to read through the code yourself.

Here is an example where Wing Pro's AI Chat tool is used to ask about the purpose of a particular class and then for more information about several methods within the class:

Shown above: Asking AI Chat to explain class Assistant and then the purpose of several of its methods that are @classmethod

Writing New Code

You can also ask the AI to write code in the context of an AI chat. Here's an example where the AI Chat is asked to produce an example of using a particular class:

Shown above: Asking AI Chat to write example code that illustrates how to use class Assistant

In this example there was significant processing time involved, but this has improved as generative AI advances, and you'll certainly receive results far faster than if you wrote the code yourself.

Although AI Chat will never modify your code directly, you can use blocks of code it produces by right-clicking on them to copy or paste into your current editor.

Getting Started

To try out AI Chat in Wing Pro, see the AI Quick Start and the rest of the AI Assisted Development documentation for details on setup, framing requests, and monitoring costs. It takes a bit of time to get started, but it is well worth the effort to incorporate generative AI into your tool chain.

That's it for now! We'll be back soon with more Wing Tips for Wing Python IDE.

As always, please don't hesitate to email support@wingware.com if you run into problems or have any questions.

Unit Testing in Wing Pro

Thu, 08 Jun 2023 01:00:00 GMT

This Wing Tip introduces the Testing tool in Wing Pro, which can be used to run and debug unit tests designed for the unittest, pytest, doctest, nose, or Django testing frameworks. Wing can collect code coverage statistics, so you can see if your tests are properly exercising your code, and so that Wing can determine which tests need to be re-run after you make edits to your code.

Identifying Test Files

You can identify files to run as tests in your project either by setting Test file patterns under the Testing tab in Project Properties (accessed from the Project menu) or by adding individual test files with Add Single File and Add Current File in the Testing menu.

Running and Debugging Tests

Once you have identified test files, you should see them listed in the Testing tool and can use the Run Tests button to run them. The Testing tool will update as tests complete, indicating which tests passed and failed. This includes display of any exception encountered and output from the tests.

Failed tests may then be debugged by selecting them in the Testing tool and pressing the Debug Tests button:

Shown above: Running unit tests in Wing Pro, inspecting test results, and debugging one failed test.

The items in the Testing menu can be used to run or re-run tests selectively, for example only those at the caret in the editor, those that previously failed, or those that have not yet been run.

Code Coverage

To enable collection of code coverage statistics, make sure you have installed coverage (for example with pip install coverage), select Use Code Coverage in the Testing tool, and then run some or all of your unit tests. Wing annotates every line of code in editors to indicate whether that line was reached by any of the unit tests that you have run. Hover the mouse cursor over lines marked in green to see which tests reached that line:

Shown above: Code coverage marks indicate which lines of code have been tested.

When code coverage is enabled, Wing will watch your edits in order to determine which previously run test results are invalidated by those edits. Any tests that reached the edited code will be marked as invalid in the Testing tool by changing the color of the test result icon to yellow:

Shown above: A unit test result is invalidated by editing code that was reached by that test. All the tests with invalidated test results are then re-run with Run Stale Tests in the Testing menu.

An HTML code coverage report and various code coverage data export options are available in the Testing menu.

For more information on unit testing and code coverage in Wing Pro, see the Unit Testing documentation.

That's it for now! We'll be back soon with more Wing Tips for Wing Python IDE.

As always, please don't hesitate to email support@wingware.com if you run into problems or have any questions.

Source Assistant in Wing Pro

Thu, 08 Jun 2023 01:00:00 GMT

This Wing Tip introduces the Source Assistant tool in Wing Pro, which provides context-sensitive at-your-fingertips code intelligence and documentation as you navigate through or write Python code.

The Source Assistant is where Wing Pro shows details about the type of a symbol, including documentation, call signature, and information about object inheritance and overridden methods. For builtin types and the standard library, this includes also links into Python documentation.

The Source Assistant is integrated with every part of Wing IDE, so it shows information for the current selection in the editor, auto-completer, Python Shell, Source Browser, Project manager, and Debug Console. It continuously updates as you move through your code or write new code.

Here are some examples of the Source Assistant in action in the editor, auto-completer, and Source Browser:

Shown above: Moving through code in the editor, the auto-completer, and Source Browser to view type signature, documentation, and other code intelligence in Wing Pro's Source Assistant tool.

See the Source Assistant documentation for details.

That's it for now! We'll be back soon with more Wing Tips for Wing Python IDE.

As always, please don't hesitate to email support@wingware.com if you run into problems or have any questions.

Live Interactive Python Coding in Wing Pro

Thu, 08 Jun 2023 01:00:00 GMT

This Wing Tip describes how to use the debugger in Wing Pro to write new Python code with direct access to the runtime state that the code is intended for, so you can immediately try out the code that you write. This is a far more efficient way to write most code, compared with working offline.

The key to working interactively in Wing is to run the debugger to a breakpoint in the code that you are working on. Once this is done, the auto-completer and other code intelligence features in Wing use both static analysis and runtime type analysis in code that is active on the debug process stack. The source of a symbol in the completer is indicated with the cog "runtime" icon.

In this context, you can immediately try out newly written code, and retry it as often as needed after correcting errors, by executing it in Wing Pro's Debug Console tool. You do need to be mindful of what the (possibly incorrect) code that you try does to the runtime state and restart the debugger if it becomes invalid. But in most cases it is possible to re-run corrected code and work iteratively without restarting your code.

Here is an example of live interactive coding in Wing Pro after running to a breakpoint in the editor:

Shown above: Entering code while the debugger is at a breakpoint, with auto-completion and auto-editing features that inspect the live runtime state of the debug process, then trying out an invocation in the Debug Console.

Notice that the above example uses a conditional breakpoint, as described in the previous Wing Tip. These are a great way to select the specific runtime case for which you want to write new code, for example to fix a bug that occurs only in a particular scenario.

Active Ranges

The above example simply copied and pasted code into the Debug Console in order to try it out. In many cases it's easier to select a range of lines that you are working on and mark those as the "active range", so that they can be executed and re-executed repeatedly as needed.

This is done by selecting the lines in the editor and pressing the active range icon in the top right of the Debug Console. Once an active range is set, the icon in the Debug Console will execute it in the current debug stack frame.

See the Interactive Debug Console documentation for details.

That's it for now! We'll be back soon with more Wing Tips for Wing Python IDE.

As always, please don't hesitate to email support@wingware.com if you run into problems or have any questions.

Auto Completion in Wing Pro

Thu, 08 Jun 2023 01:00:00 GMT

In this issue of Wing Tips we introduce Wing Pro's auto-completer, which can be used to find and more quickly enter symbols, imports, and snippets into Python code.

By default, Wing shows the auto-completer as you type in the editor, populating the completer with whatever code symbols and snippets are relevant to the particular context you are working in. The arrow keys can be used to move up and down the completion list and a completion is selected by pressing Tab or other completion key configured with the Editor > Auto-completion > Completion Keys preference in Wing. The same preferences group lets you specify whether to show the completer immediately or only after a certain number of characters or elapsed time, how to place the completion, and various other options.

Here is what the completer looks like in action:

Shown above: Using the auto-completer to enter new Python code in Wing Pro.

Notice that the auto-completer contains two columns of icons like and that indicate the origin and type of the symbol. These are described in detail in Auto-completion Icons.

Auto-Import

In Wing 9.1 and later the auto-completer also contains suggestions for modules you may want to import for the code that you are writing. When these completions are selected, Wing enters the symbol for the selected import at the current position in the editor and also adds the necessary import statement at the top of your file:

Shown above: Using the auto-completer to enter code and new import statements simultaneously.

The Editor > Auto-completion > Python Auto-Imports preference controls whether to always show auto-imports, show them only on request, or to hide them entirely from the completer. See also the Imports tool.

Snippets

The completer also offers code snippets appropriate for the current context. These are indicated with the scissors icon. The default set of snippets that come with Wing Pro may be viewed and altered in the Snippets tool in the Tools menu.

Here is an example of entering snippets with the auto-completer, using the Tab key to move between and fill out fields in the snippets:

Shown above: Using the auto-completer to enter code snippets for a class, a method, and a nested definition, showing how snippets can take different forms depending on their context in the code.

See the Code Snippets documentation for more information.

That's it for now! We'll be back next week with more Wing Tips for Wing Python IDE.

Turbo Completion Mode in Wing Pro

Wed, 19 Jan 2022 01:00:00 GMT

In this issue of Wing Tips we look at how to use Wing Pro's turbo completion mode for Python. Auto-completion normally requires pressing a completion key, as configured by the Editor > Auto-completion > Completion Keys preference, before a completion is entered into the editor.

Wing Pro also provides a Python Turbo Mode for auto-completion, where completion occurs on any key that cannot be part of a symbol. This allows you to type just enough of a symbol until it is selected in the completer, then move right on to typing the code that follows that symbol. It takes some getting used to, but it can greatly reduce typing once you become comfortable with it.

The following example shows the code that can be produced simply by typing the characters p=x.p.e.P( without pressing any completion keys:

This particular case requires only a single character to match each symbol in the auto-completer. In a more cluttered name space, it may take more characters to match the desired symbol, but in many cases two or three characters is all that is needed before you can move on to the next part of the expression you are trying to type.

Notice that turbo mode distinguishes between contexts where a new symbol may be defined and those where an existing symbol must be used. For example, if you type c followed by = on a new line, Wing knows that the = indicates you may be defining a new symbol and does not place the current selection from the auto-completer. When you do want completion to occur in a defining context, you can press Tab or another completion key.

In a context where you are trying to type something other than what is in the completer, you can press Ctrl, Alt or Command briefly by itself to hide the auto-completer and thus disable turbo-completion until you type more symbol characters and the completer is displayed once again.

Turbo completion is enabled with the Editor > Auto-completion > Python Turbo Mode preference in Wing Pro.

That's it for now! We'll be back next week with more Wing Tips for Wing Python IDE.

Debug Python Code Run by Docker Compose with Wing Pro

Tue, 21 Sep 2021 01:00:00 GMT

This Wing Tip describes how to configure Docker Compose so that Python code running on selected container services can be debugged with Wing Pro. This makes it easy to develop and debug containerized applications written in Python.

Getting Started

Before you can work with Docker Compose you will need to download and install it and then create a working test cluster. See Install Docker Compose for details.

You should also install Wing Pro if you don't already have it.

Configuration

To configure Wing to use New Project in the Project menu. After selecting your source directory, choose Use Existing Python on the second dialog page, and then select Cluster:

Next create a new cluster configuration by pressing the New button. This displays the cluster configuration dialog. You will need to enter an identifier to use within Wing and point it at the docker-compose.yml file for the cluster. You will also need to select the main service to use as the default place to run your Python Shell and unit test processes:

Once you have created your cluster configuration, submit the New Project dialog to complete your project setup.

Working with the Cluster

You can now control your cluster from Wing's Containers tool, found in the Tools menu. This tool lists the services in your cluster and their status. You can right-click on items here or use the Options menu to build, start, debug, and stop your cluster:

Debug processes, unit tests, Wing's integrated Python Shell and OS Commands can all be run in context of the cluster, or optionally instead within isolated containers that match the cluster configuration but run without launching the whole cluster.

See Using Wing Pro with Docker Compose for more information working with clusters in Wing Pro.

That's it for now! We'll be back soon with more Wing Tips for Wing Python IDE.

As always, please don't hesitate to email support@wingware.com if you run into problems, have any questions, or have topic suggestions for future Wing Tips!

Wing Tips

Unit Testing with the AI Agent in Wing Pro 12

Setting the Testing Regimen

Iterating on Failures

Fixing Code Warnings with the AI Agent in Wing Pro 12

Fix in the Editor

Fix Many at Once

Working with Tests and the Claude Code Agent in Wing Pro 12

Testing Regimen

Running Tests via Wing's Testing Tool

Code Coverage

Further Reading

Using the Tasks Tool with the Claude Code Agent in Wing Pro 12

Entering and Queueing Requests

Following Up Within a Task

Execution Mode and Context

Further Reading

Reviewing and Accepting Agent Changes in Wing Pro 12

Change Tracking and Review

Commit Modes

History

Further Reading

Introducing the Claude Code Agent in Wing Pro 12

Setup

Your First Session

Where to Next

Further Reading

Best Practices for Working with the Claude Code Agent in Wing Pro 12

Basic Principles

AI Safety

Treat the Agent Like a Capable Employee

Cross-Check from Different Angles

Review at the Behavior Level

When the Agent Gets Stuck

Understanding Context and Token Costs

Further Reading

Legacy AI Assisted Development in Wing Pro

Legacy AI Chat in Wing Pro

Unit Testing in Wing Pro

Identifying Test Files

Running and Debugging Tests

Code Coverage

Source Assistant in Wing Pro

Live Interactive Python Coding in Wing Pro

Active Ranges

Auto Completion in Wing Pro

Auto-Import

Snippets

Turbo Completion Mode in Wing Pro

Debug Python Code Run by Docker Compose with Wing Pro

Getting Started

Configuration

Working with the Cluster