Audit Log For Loan Operations With Copilot: A Workshop

In this workshop-style article, we'll delve into the process of designing and implementing an audit log for loan operations using GitHub Copilot Chat. Our primary goal isn't just to write code, but to explore how Copilot can assist us in various stages, including requirement analysis, technical design, issue breakdown, and solution implementation. This approach ensures that we not only create a functional feature but also learn how to leverage AI tools to enhance our development workflow.

High-Level Goal: Adding an Audit Log Feature

Our main objective is to add an "audit log" feature that meticulously records significant actions performed on loans. These actions include loan creation, status changes (such as approval or rejection), and automated decision events. The audit log should be easily queryable, primarily for UI display and debugging purposes, and its design should prioritize simplicity and maintainability. By focusing on these key aspects, we ensure that the audit log is not only functional but also aligns with the project's overall architecture and objectives.

Exploring the Current Repository with Copilot Chat

The initial step in our workshop involves leveraging Copilot Chat to gain a comprehensive understanding of the existing codebase. This exploration phase is crucial for identifying key components and understanding their interactions, which forms the foundation for our audit log design. By asking Copilot to explain the workings of loanService, we can quickly grasp its functionality and how it manages loan operations. Furthermore, we'll inquire about functions that modify the state of a loan and the conditions under which they are invoked. This targeted questioning allows us to efficiently pinpoint the critical areas where audit logging needs to be implemented, ensuring that we capture all relevant actions.

To effectively use Copilot Chat for code exploration, consider asking questions such as:

• "Can you explain how the loanService works?"
• "Which functions change the state of a loan?"
• "When are these functions called?"

These questions will help you understand the current architecture and identify key areas for implementing the audit log.

Proposing an Audit Log Design with Copilot Chat

Once we have a solid understanding of the existing codebase, the next step is to utilize Copilot Chat to propose a robust and efficient audit log design. This phase involves brainstorming the essential components of an audit log entry and determining the most suitable storage mechanism. We'll ask Copilot to suggest what information each log entry should contain, such as the timestamp of the action, the type of action performed, the loan ID, and any changes in loan status (e.g., from pending to approved). Additionally, we'll explore different storage options, such as in-memory storage combined with local storage persistence or a dedicated module for audit logs. The goal is to strike a balance between functionality and simplicity, ensuring that the audit log integrates seamlessly with the existing application architecture.

To guide Copilot Chat in proposing an effective audit log design, consider posing the following questions:

• "What information should an audit log entry contain (e.g., timestamp, action type, loan ID, previous/new status)?"
• "Where should we store these entries (e.g., in-memory + localStorage, or a separate module)?"
• "How can we keep the implementation simple and consistent with the existing app?"

By addressing these questions, we can establish a clear and concise audit log design that meets the project's requirements without overcomplicating the codebase.

Generating Sub-Issues with Copilot Chat

With a design in place, the next crucial step is to break down the implementation process into manageable sub-issues. Copilot Chat can be a valuable tool in this phase, helping us generate a list of concrete, small tasks that need to be completed. We'll prompt Copilot to suggest a set of sub-issues necessary for implementing the audit log feature. Examples of such issues might include creating the audit log data model and storage mechanism, recording loan creation events, tracking status changes (approve/reject/auto-decide), displaying audit log entries in the UI, and adding comprehensive tests for audit log behavior. Once Copilot provides its suggestions, we'll thoroughly review them to ensure that each issue is focused, achievable, and covers all important scenarios.

To effectively use Copilot Chat for generating sub-issues, ask questions such as:

• "Suggest a set of concrete, small issues needed to implement the audit log feature."

Copilot might propose issues like:

• "Create audit log data model and storage"
• "Record loan creation events in the audit log"
• "Record status changes (approve/reject/auto-decide)"
• "Display audit log entries in the UI"
• "Add tests for audit log behavior"

After receiving these suggestions, review them critically. Are the issues small and focused? Do any need further splitting? Are all essential scenarios covered? This review process ensures that we have a well-defined set of tasks that can be efficiently tackled.

Refining and Atomizing Issues

After generating an initial list of sub-issues with Copilot Chat, the next critical step is to refine and atomize these issues to ensure they are clear, actionable, and manageable. This process involves carefully reviewing each suggested issue and making necessary edits or rewrites to enhance clarity and focus. The goal is to create issue titles that are descriptive and action-oriented, making it easy for developers to understand the task at hand. Additionally, we aim to keep the scope of each issue small, ensuring that it can be completed within a short timeframe. This approach not only promotes efficient workflow but also allows for incremental progress and easier tracking.

To refine and atomize the issues effectively, consider the following guidelines:

• Clarity: Ensure that the issue titles are clear and concise, accurately reflecting the task. For example, instead of a vague title like