In the first part of this blog, we discussed how coding could be a collaborative experience using tools like the GitHub Copilot. In the second part, we will explore the impact and significance of collaboration due to GitHub Copilot on the wider developer ecosystem.
As we have seen, developers have a specific definition of collaboration that spans internally i.e. within their teams – but also externally i.e. beyond their teams.
In this blog, we will discuss the possible impact of GitHub Copilot within the wider ecosystem.
To under this potential impact, let’s first look at the limitations of Agile itself
The article Why Are There So Many Misconceptions Around Agile?
- The agile manifesto establishes abstract principles for skilled practitioners in a healthy environment.
- But novices can’t apply such abstract principles directly, they have to start with unambiguous, context-free, concrete rules. So it’s perfectly natural, to begin with concrete, hard-and-fast rules such as a two-week iteration or a stand-up meeting with a fixed format.
- But while rules are effective to help beginners get started, they also then limit you to beginner levels of performance
- Agile is a mindset and approach used for working effectively in complex domains.
- As such, the Agile manifesto was really aimed at skilled practitioners in a healthy environment. But most people work in unhealthy work environments with low psychological safety and degraded information flows.
- Additionally, many team members have a desire to “just be told what to do”—in other words, concrete rules.
- But agile is all about being able to adapt quickly in volatile and uncertain environments, so there will never be concrete rules to tell you what to do.
In other words, software development is a complex adaptive system
According to Wikipedia
A complex adaptive system is a system that is complex in that it is a dynamic network of interactions, but the behavior of the ensemble may not be predictable according to the behavior of the components. It is adaptive in that the individual and collective behavior mutate and self-organize corresponding to the change-initiating micro-event or collection of events. It is a “complex macroscopic collection” of relatively “similar and partially connected micro-structures” formed in order to adapt to the changing environment and increase their survivability as a macro-structure. The Complex Adaptive Systems approach builds on replicator dynamics.
Software development can be considered a complex adaptive system due to several key characteristics:
- Emergence: In software development, complex behaviors, and patterns emerge from the interaction of numerous components and agents, such as developers, code modules, and user feedback. The system as a whole exhibits behaviors that cannot be predicted solely by understanding the individual parts.
- Non-linearity: Software development involves interconnected elements and dependencies that can lead to non-linear and unpredictable outcomes. Small changes in one part of the system can have disproportionate and unexpected effects on other parts.
- Feedback loops: Software development relies on feedback loops to adapt and improve. Feedback can come from various sources, including users, stakeholders, and testing. This feedback helps identify issues, refine requirements, and guide the development process, enabling continuous learning and adaptation.
- Self-organization: Within a software development project, teams and individuals self-organize and adapt their workflows based on changing circumstances. Developers collaborate, make decisions, and adjust their strategies to meet project goals and respond to challenges, without relying on a centralized command structure.
- Uncertainty and variability: Software development is characterized by inherent uncertainty and variability. Requirements can change, technology can evolve, and unforeseen challenges can arise. Developers must adapt their plans, employ creative problem-solving, and make trade-offs to navigate these uncertainties effectively.
- Co-evolution: Software development involves a co-evolution between the software being developed and the development process itself. As developers gain experience and learn from previous projects, they refine their practices and tools, leading to the evolution of the development process and improving future software products.
- Scalability: Software development projects can scale from small teams working on a single feature to large distributed teams working on complex systems. The interactions and dependencies within the system must adapt to accommodate the growing scale, requiring flexible coordination and communication mechanisms.
The book Practices of an Agile Developer: defines Agile in terms of collaboration
Agile Development uses feedback to make constant adjustments in a highly collaborative environment.
Specifically,
- Lack of collaboration is often seen when you have little to no stakeholder or user involvement
- Even if you are getting feedback, you have to act on it ie constantly adjust.
Now, when it comes to using tools like GitHub Copilot for coding, then there are some best practices based on testing ex: iterate and test in chunks
If we see test scripts as a touch point to manage complex adaptive systems then the testpilot from copilot labs
Leveraging the cutting-edge machine-learning models powering GitHub Copilot, TestPilot creates readable unit tests with meaningful assertions for your JavaScript/TypeScript code.
TestPilot takes the pain out of writing unit tests. It uses GitHub Copilot’s AI technology to suggest tests based on your existing code and documentation. Unlike many other tools, TestPilot generates readable tests with meaningful assertions, and it can iteratively improve its suggestions based on your feedback.
To conclude, while the testpilot feature is new, it could play an important role in the future.
Image source: traffic flows. An example of a complex adaptive system
Image source: https://pixabay.com/photos/hongkong-street-view-central-1886027/
