Skip to content

Exploring Generative AI

TDD with GitHub Copilot

by Paul Sobocinski

Will the appearance of AI coding assistants similar to GitHub Copilot imply that we gained’t want exams? Will TDD change into out of date? To reply this, let’s look at two methods TDD helps software program growth: offering good suggestions, and a way to “divide and conquer” when fixing issues.

TDD for good suggestions

Good suggestions is quick and correct. In each regards, nothing beats beginning with a well-written unit take a look at. Not handbook testing, not documentation, not code overview, and sure, not even Generative AI. In truth, LLMs present irrelevant data and even hallucinate. TDD is particularly wanted when utilizing AI coding assistants. For a similar causes we’d like quick and correct suggestions on the code we write, we’d like quick and correct suggestions on the code our AI coding assistant writes.

TDD to divide-and-conquer issues

Drawback-solving through divide-and-conquer implies that smaller issues could be solved prior to bigger ones. This permits Steady Integration, Trunk-Primarily based Growth, and in the end Steady Supply. However do we actually want all this if AI assistants do the coding for us?

Sure. LLMs not often present the precise performance we’d like after a single immediate. So iterative growth shouldn’t be going away but. Additionally, LLMs seem to “elicit reasoning” (see linked examine) once they clear up issues incrementally through chain-of-thought prompting. LLM-based AI coding assistants carry out finest once they divide-and-conquer issues, and TDD is how we try this for software program growth.

TDD suggestions for GitHub Copilot

At Thoughtworks, we have now been utilizing GitHub Copilot with TDD because the begin of the yr. Our aim has been to experiment with, consider, and evolve a sequence of efficient practices round use of the device.

0. Getting began

TDD represented as a three-part wheel with 'Getting Started' highlighted in the center

Beginning with a clean take a look at file doesn’t imply beginning with a clean context. We regularly begin from a person story with some tough notes. We additionally speak by way of a place to begin with our pairing associate.

That is all context that Copilot doesn’t “see” till we put it in an open file (e.g. the highest of our take a look at file). Copilot can work with typos, point-form, poor grammar — you identify it. However it may’t work with a clean file.

Some examples of beginning context which have labored for us:

  • ASCII artwork mockup
  • Acceptance Standards
  • Guiding Assumptions similar to:
    • “No GUI wanted”
    • “Use Object Oriented Programming” (vs. Practical Programming)

Copilot makes use of open information for context, so protecting each the take a look at and the implementation file open (e.g. side-by-side) enormously improves Copilot’s code completion capability.

1. Pink

TDD represented as a three-part wheel with the 'Red' portion highlighted on the top left third

We start by writing a descriptive take a look at instance identify. The extra descriptive the identify, the higher the efficiency of Copilot’s code completion.

We discover {that a} Given-When-Then construction helps in 3 ways. First, it reminds us to supply enterprise context. Second, it permits for Copilot to supply wealthy and expressive naming suggestions for take a look at examples. Third, it reveals Copilot’s “understanding” of the issue from the top-of-file context (described within the prior part).

For instance, if we’re engaged on backend code, and Copilot is code-completing our take a look at instance identify to be, “given the person… clicks the purchase button, this tells us that we should always replace the top-of-file context to specify, “assume no GUI” or, “this take a look at suite interfaces with the API endpoints of a Python Flask app”.

Extra “gotchas” to be careful for:

  • Copilot could code-complete a number of exams at a time. These exams are sometimes ineffective (we delete them).
  • As we add extra exams, Copilot will code-complete a number of traces as an alternative of 1 line at-a-time. It should typically infer the right “organize” and “act” steps from the take a look at names.
    • Right here’s the gotcha: it infers the right “assert” step much less typically, so we’re particularly cautious right here that the brand new take a look at is appropriately failing earlier than transferring onto the “inexperienced” step.

2. Inexperienced

TDD represented as a three-part wheel with the 'Green' portion highlighted on the top right third

Now we’re prepared for Copilot to assist with the implementation. An already present, expressive and readable take a look at suite maximizes Copilot’s potential at this step.

Having mentioned that, Copilot typically fails to take “child steps”. For instance, when including a brand new methodology, the “child step” means returning a hard-coded worth that passes the take a look at. To this point, we haven’t been capable of coax Copilot to take this method.

Backfilling exams

As an alternative of taking “child steps”, Copilot jumps forward and supplies performance that, whereas typically related, shouldn’t be but examined. As a workaround, we “backfill” the lacking exams. Whereas this diverges from the usual TDD stream, we have now but to see any severe points with our workaround.

Delete and regenerate

For implementation code that wants updating, the best method to contain Copilot is to delete the implementation and have it regenerate the code from scratch. If this fails, deleting the tactic contents and writing out the step-by-step method utilizing code feedback could assist. Failing that, one of the best ways ahead could also be to easily flip off Copilot momentarily and code out the answer manually.

3. Refactor

TDD represented as a three-part wheel with the 'Refactor' portion highlighted on the bottom third

Refactoring in TDD means making incremental modifications that enhance the maintainability and extensibility of the codebase, all carried out whereas preserving habits (and a working codebase).

For this, we’ve discovered Copilot’s capability restricted. Contemplate two situations:

  1. “I do know the refactor transfer I wish to attempt”: IDE refactor shortcuts and options similar to multi-cursor choose get us the place we wish to go quicker than Copilot.
  2. “I don’t know which refactor transfer to take”: Copilot code completion can’t information us by way of a refactor. Nevertheless, Copilot Chat could make code enchancment options proper within the IDE. Now we have began exploring that characteristic, and see the promise for making helpful options in a small, localized scope. However we have now not had a lot success but for larger-scale refactoring options (i.e. past a single methodology/perform).

Typically we all know the refactor transfer however we don’t know the syntax wanted to hold it out. For instance, making a take a look at mock that will permit us to inject a dependency. For these conditions, Copilot might help present an in-line reply when prompted through a code remark. This protects us from context-switching to documentation or net search.


The frequent saying, “rubbish in, rubbish out” applies to each Knowledge Engineering in addition to Generative AI and LLMs. Acknowledged otherwise: larger high quality inputs permit for the aptitude of LLMs to be higher leveraged. In our case, TDD maintains a excessive stage of code high quality. This prime quality enter results in higher Copilot efficiency than is in any other case doable.

We subsequently advocate utilizing Copilot with TDD, and we hope that you simply discover the above suggestions useful for doing so.

Because of the “Ensembling with Copilot” workforce began at Thoughtworks Canada; they’re the first supply of the findings coated on this memo: Om, Vivian, Nenad, Rishi, Zack, Eren, Janice, Yada, Geet, and Matthew.

Ready to get a best solution for your business?