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 AI 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 the agent 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 development guides in the .wing directory, which every agent reads, so each new agent session 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 Autonomous Development with AI Agents.

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 AI 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 Autonomous Development with AI Agents.

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 AI Agents in Wing Pro 12

Fri, 10 Jul 2026 01:00:00 GMT

This Wing Tip continues the series on AI agents 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 the agent 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 takes the form of development guides, which Wing writes into the .wing directory when you set up the agent. These describe the development methodology to follow, and nudge the agent towards using the MCP tools in a way that reduces wall time and token use.

Some of the larger gains seen in our benchmarks, which were run with Claude Code, were the result of providing the agent 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 tab in Project Properties. By default -- the Minimal regimen -- Wing asks the agent 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 agent 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 an agent uses Wing's unit testing MCP server, it always runs tests with code coverage enabled. This allows it to run just stale tests after making code changes, which can save a lot 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.

Tests matter even more when agents work autonomously with the Tasks Manager: without them, workers can't tell whether their code functions correctly, and the work stops often to ask you. See the Wing Tip on autonomous development.

Using the Tasks Tool with AI Agents 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 AI agents.

There are actually two ways to talk to an agent: (1) by typing directly in the AI Agent tool or (2) through the Tasks tool, which runs each request as a queued unit of work. Both feed the same agent sessions, 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 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

To add a task, open the Tasks tool from the Tools menu if it isn't visible, and use the + button on its Plan tab, in either the Goals or the Tasks view.

A task you type starts as a Draft, so nothing runs it while it is half written. Click its Draft pill to mark it Ready when you're done, which tells the Tasks Manager (when it is on) that it can queue the task. To run a task yourself, queue it from its Q menu. While the Tasks Manager is on, the Q menu is hidden: right-click on the task and select one of your own queues from its Queue submenu instead.

Keeping the Plan Manageable

Once your plan holds more goals than you are working on, you can set some aside. Now, Later, and All, on the line below the Goals, Tasks, and Incoming views, choose which goals are shown. To set a goal aside, click the clock icon in its header. Its Ready tasks become Drafts, and the Tasks Manager leaves them alone until you make one Ready yourself or bring the goal back. Clicking the goal's clock again brings it back to Now.

Outline and Focus, at the right of the same line, set how goals open. In Outline, the default, each goal opens and closes on its own. In Focus, opening a goal closes the others, and double-clicking on any goal focuses on it. The Compact / Expanded button above them switches between showing the whole text of each task and a single line:

Shown above: The Goals view in Now and Outline, with one goal open.

Running Queued Tasks

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, use the play icon on the queue to start its next task. To stop a running task early, use its Cancel action. A task left interrupted offers Move to Review to keep what it has done so far, or Reset to return it to the Plan tab.

The Execute tab has two views. Queues shows your queues at the top and the selected queue's tasks below. Up Next shows what runs next in every queue, followed by the Ready tasks that no queue holds yet, and points out tasks the Tasks Manager has just queued. Click a queue's name there to show its session in the AI Agent tool:

Shown above: Up Next with two queues running, a task the Tasks Manager just queued, and a Ready task that no queue holds yet.

Queueing makes it easy to batch related work and walk away, for example with a Bug Fixes queue for small fixes as you think of them and other queues for larger work. Be mindful of agents changing the same code at once, and ask an agent to keep to specific files or directories when that helps. Wing tracks which files each task changes, so you can commit the work of different queues separately.

Even when the Tasks tool isn't visible, the agent status area at the right end of the main toolbar shows whether agents are running, how many queues are waiting for your input, and a button that jumps to changes ready for review.

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 are covered in a later Wing Tip.

Letting the Tasks Manager Do the Queueing

Once you are running more than a few tasks, deciding which ones can run at the same time, watching queues, and looking through sessions for questions becomes work in itself. The Tasks Manager is an agent that can do this for you. Turn it on from the Options menu or the Turn On button at the top of the Execute tab, write your tasks, and mark them Ready. The Manager creates its own queues, runs what can safely run side by side, and collects every agent's questions on the Questions tab.

With the Manager on, tasks run autonomously: each works as far as it can and ends with a report of what it did, the judgement calls it made, and any questions it still has. Many people work with a single agent for a while before turning on the Manager, and others use it from the start; it's up to you. Autonomous development with the Manager is covered in detail in the next Wing Tip.

Triaging What Agents Found

Agents often notice problems outside the task they are working on, and the Tasks Manager proposes follow-up work as it goes. These arrive as Drafts on the Plan tab, and its Incoming view lists the ones you haven't looked at yet, grouped by goal, with their number shown beside Incoming. Seen leaves a task as a Draft in its goal, Dismiss deletes it, and clicking its pill makes it Ready. From the keyboard, J and K move between tasks, and R, S, and D make the selected task Ready, mark it seen, or dismiss it:

Shown above: The Incoming view in Compact rows, with a problem an agent found and a test the Tasks Manager proposed.

On the Plan and Execute tabs, tasks you didn't write carry a chip saying where they came from: Found, Manager, Fix, or Check. Tasks that agents found or proposed also have a colored bar down their left edge. Hover over a chip to see the task's origin, or click it to show the agent session that filed the task.

Following Up Within a Task

While a task is running, or after it completes, you can send follow-up requests within the same agent 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 AI Agent tool to continue the same session -- here, asking the agent to update the documentation for the change it just made.

Run Mode and Context

Before you queue a task, its Q menu chooses its queue and whether it starts a new agent session or reuses the queue's session. A new session for each task tends to save on tokens. Reuse the session when a series of tasks benefits from knowing what came before.

A new session also sets the run mode. Plan has the agent explore the code and write a plan without making any edits, which you can revise before approving it. Use it for larger or riskier changes, for tracking down a difficult bug, and for safely reading code that another task is changing. Ask For Approval asks before acting, except for what you have pre-approved on the AI Agent tab of Project Properties (by default, edits inside the project). Auto-Approve, the default, lets the agent's own judgement decide what to ask about. The Q menu lists only the modes the queue's agent supports, and Wing warns before starting a task in a mode that the agent handles more broadly than you might expect.

While the Tasks Manager is on, the Q menu is hidden, because the Manager chooses each task's queue, session, and run mode. To have a task researched and planned before it is carried out in any case, right-click on it and check Research First.

When reusing a session, Full Context keeps the whole conversation, and Compact Context, for agents that can compact, summarizes it first. Compacting consumes tokens itself, so it makes sense only in longer series of related tasks:

Shown above: Choosing Plan from a task's Q menu, so the agent writes a plan before it changes any code.

Reviewing and Accepting Agent Changes in Wing Pro 12

Fri, 10 Jul 2026 01:00:00 GMT

This Wing Tip continues the series on AI agents 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, 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 that aren't committed yet, you can click on the diff/merge icons in the Review tab to visit the changed files and view the differences. More often, you will use the Start Review or Commit 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 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 an agent's work. You can also run tests or ask another agent to review the work. How much you read at the code level is up to you, and will likely change as you gain confidence in your tests and cross-checks.

A task that ran autonomously through the Tasks Manager (see the Wing Tip on autonomous development) shows a summary report of what it did and the decisions it made on your behalf, with the reasoning and alternatives for each. You can disagree with any of these and send it back with a description of what you want changed.

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:

The agent commits only when asked -- The default. The agent never commits on its own; when you approve a review or use Commit, it writes a commit message from the work it just did and then does the commit.

The agent commits after each task -- The agent commits on its own at the end of every completed task whose tests pass, without waiting for you.

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

Wing commits with generated message -- Wing commits immediately, without involving the agent, 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 commit dialog, waiting for you to review the message and complete the commit yourself.

When the Tasks Manager is enabled for autonomous task queueing, its own Commits setting overrides the above. It will either leave finished work on Review for you, commit automatically once tests pass, or follow a policy that you describe, such as "commit code automatically, but leave documentation changes for me to review". If you let the Manager commit on its own, consider working on a separate branch, so you stay in control of when the work is merged into your main branch. Note that even if the Tasks Manager commits for you, tasks land on the Review tab and you can still reject or revisit each decision it made.

History

Once you have committed work done by a task, or marked it complete, 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 Tasks tool's Options menu.

From here (and in fact also from the Review tab) you can expand each task to see the agent's responses and any follow-up requests made in the same session (often as typed directly into the AI Agent 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 tab. This is a good way to estimate how expensive tasks were.

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

Introducing AI Agents in Wing Pro 12

Fri, 10 Jul 2026 01:00:00 GMT

Wing Pro 12 integrates your choice of AI coding agent: Claude Code, Codex, Antigravity, Copilot, Cursor, goose, OpenCode, or any other agent that supports the Agent Client Protocol. You can use Wing to queue agent requests, manage their execution, and review and audit each completed task before committing changes. Wing also gives the agent tools for code analysis, unit testing, debugging, and version control, in a way that reduces both elapsed time and token use.

This Wing Tip is part of a series of Wing Tips on working with AI agents in Wing.

Shown above: The Tasks Manager running three queues on the Tasks tool's Execute tab, beside one queue's session in the AI Agent tool.

Setup

To get started:

Install or upgrade to Wing Pro 12.
Install the agent you want to use, and get an account or API key for it if you don't already have one. Setting Up an AI Agent lists what each agent needs. For sustained use, a subscription is generally much cheaper than paying for usage on an API key.
From the Project menu, choose New Project, check Set Up for AI Agent, choose your agent, enable the autonomous task manager for easier implementation workflow, 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 AI Agent from the Project menu.
Set your new or existing project up in a revision control repository. You can use an agent without it, but Wing's task review features won't work. Even a local git repository (in the same directory as your sources) will work. Ask the agent for help with setup.

Your First Session

Type a request into the AI Agent 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: Choosing a queue for a task from its Q menu, which also sets the run mode (such as Plan).

If the result isn't quite right, follow up in the same session -- 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

Once you are comfortable working with one agent, you can turn on the Tasks Manager to have agents carry out a series of tasks on their own, while you write tasks, answer questions, look over the problems agents find in the Plan tab's Incoming view, and review the results. When to take that step is up to you. See the Wing Tip on autonomous development for how to get started.

The other Wing Tips in this series look more closely at:

The Tasks tool as a way to manage one or more AI agents.
Autonomous development with the Tasks Manager.
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 AI actions in the editor to explain, review, or optimize code -- see Autonomous Development with AI Agents for the full picture.

Best Practices for Working with AI Agents in Wing Pro 12

Fri, 10 Jul 2026 01:00:00 GMT

This is the closing Wing Tip in the series on AI agents in Wing Pro 12. It collects the habits that produce reliable results.

Basic Principles

The fact that AI agents work as well as they do is remarkable, given that the LLMs that underlie them are (famously) prone to 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

The better AI agents have good safety controls out of the box. But like people, they can make mistakes, and when they do, they make them very quickly.

In order for an agent's 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 an agent 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 the agent 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 the agent for solutions is a great way to find relatively easy ways to set up an environment you are comfortable with. See also AI Agent Safety in Wing's documentation.

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 instructions, which may be a one-line bug fix or a high-level specification that the agent researches and breaks into smaller tasks. It includes unit testing. It may include independent AI agent validation of work for correctness, performance, security, and other metrics.

Write down your development policies too, from coding style to workflow rules, in AGENTS.md (outside the block Wing maintains there). Agents read it at the start of every session.

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 there 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 AI actions in the editor's Code Actions menu -- Review for Security Risks, Review for Code Quality, and Optimize Code -- each of which frames the request for you.

When agents work autonomously with the Tasks Manager, make some of these review passes a regular part of your workflow, as tasks of their own at key points. Each can turn up problems that become new tasks.

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's report -- its summary and judgement calls -- 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 the agent to do that.

How much you read at the code level is up to you, and your answer will likely change over time. Once you trust your tests and cross-checks, you may find yourself reading reports and committing without reading every diff, and turning on the Tasks Manager so agents can carry out a series of tasks on their own. See the Wing Tip on autonomous development.

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, an agent 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 use Clear Conversation in the AI Agent tool's Options menu 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

An agent uses both its already-learned knowledge about the software development process, from its original training, and also facts it has learned about your development environment and project. When you set up an agent with Set Up for AI Agent, Wing writes development guides into the .wing directory, describing how to use Wing's tools and your project's testing regimen and commit policy, and points AGENTS.md at them. Wing also offers to run the agent's own project analysis, if it has one, so the agent starts with its own notes about your code as well.

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

This is a simplification, but enough to be able to manage what really matters here -- token use. The more the agent 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.

Wing helps with that. We've designed the Tasks tool and the MCP servers that agents use to keep token consumption lower. In our initial benchmarks, run with Claude Code, 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 clear the conversation in an agent session, or when to use the Q menu in the Tasks tool to change the session reuse and run modes (as discussed in an earlier Wing Tip) to use context when relevant and discard it when not. When the Tasks Manager is enabled, it makes these choices for you, running closely related tasks in the same session so later ones keep the context of earlier ones. Setting goals aside with the clock icon in their headers on the Plan tab keeps both your plan and the Manager focused on current work.

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 integration of AI agents such as Claude Code, Codex, and Copilot, see Autonomous Development with AI Agents.

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 integration of AI agents such as Claude Code, Codex, and Copilot, see Autonomous Development with AI Agents.

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.

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 AI Agents in Wing Pro 12

Testing Regimen

Running Tests via Wing's Testing Tool

Code Coverage

Further Reading

Using the Tasks Tool with AI Agents in Wing Pro 12

Entering and Queueing Requests

Keeping the Plan Manageable

Running Queued Tasks

Letting the Tasks Manager Do the Queueing

Triaging What Agents Found

Following Up Within a Task

Run Mode and Context

Further Reading

Reviewing and Accepting Agent Changes in Wing Pro 12

Change Tracking and Review

Commit Modes

History

Further Reading

Introducing AI Agents in Wing Pro 12

Setup

Your First Session

Where to Next

Further Reading

Best Practices for Working with AI Agents 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