AI is changing the way software developers approach their daily work. It is no longer limited to generating a method, explaining an error, or completing a few lines of code.
AI coding tools can now work with an entire codebase, understand existing implementations, analyze requirements, create implementation plans, modify multiple files, run tests, investigate failures, and help developers move from an idea to a working solution much faster.
Recently, we have been using Claude Enterprise with Claude Code, together with the GSD (Get Shit Done) approach and its associated skills, as part of our software development workflow.
The experience has been interesting because the biggest productivity improvement does not come from simply asking AI to "write code." It comes from giving AI a structured way to understand the problem, work through the implementation, verify the result, and iterate.
In this article, I'll share how we are using this approach, where it can help developers, what we can delegate to AI, and where human involvement is still critical.
What Exactly Is Claude Code?
Claude Code is an AI-powered coding environment that can work directly with a software repository. Instead of copying a small piece of code into a chatbot and asking for a solution, developers can give Claude access to the project and allow it to work with the actual codebase.
Depending on the task and permissions, Claude can:
- Explore the repositories — in our case, Claude can map and understand multiple codebases.
- Read and understand existing code
- Analyze dependencies
- Search for relevant implementations
- Understand project structure
- Plan changes
- Modify files
- Create new files
- Run commands
- Run tests
- Investigate test failures
- Fix implementation issues
- Review changes
- Help with Git workflows
- Generate or update documentation
What Is GSD?
GSD stands for Get Shit Done.
The important idea behind the approach is not simply getting AI to generate code quickly. It is about giving the development task a structured execution process. A large requirement can be broken down into smaller, manageable tasks.
This approach makes AI much more useful for real-world development.
Our Setup — Claude Enterprise, Claude Code & IntelliJ IDEA
For our development work, we have been using Claude Enterprise with Claude Code along with IntelliJ IDEA.
One of the useful aspects of Claude Code is that it can work with the actual project rather than requiring us to copy individual classes or code snippets into a chat.
In our case, we also work with multiple code repositories. Claude can explore the relevant repositories and help us understand how different components are connected and where a particular change may need to be made.
This is particularly useful when a requirement crosses application boundaries or when we need to understand an existing implementation before making changes.
For this article, I've used Claude Code with IntelliJ IDEA as my development environment. However, Claude Code isn't limited to IntelliJ IDEA. You can use it with your preferred IDE or directly from the command prompt/terminal, depending on your development workflow and setup.
GSD Approach — How We Structure the Work
One of the key parts of our workflow is the GSD approach. Instead of immediately asking Claude to implement a requirement, we first allow it to understand the problem and the existing codebase.
A simplified version of the workflow looks like this:
Requirement → Understand → Research → Plan → Implement → Test → Review → Refine
This approach is useful for larger development tasks where simply generating code isn't enough. For example, before implementing a change, Claude can first explore the relevant repositories, identify the existing implementation, look at related tests, and understand how different components interact.
It can then create a plan for the proposed change. This gives us an opportunity to review the approach before implementation begins. The important part is that the developer remains in the loop.
We don't simply provide a requirement and accept whatever code is generated. We review the understanding, validate the proposed approach, provide additional context where required, and then allow the implementation to proceed.
If you're starting a new project
The typical workflow is:
/gsd-new-project
↓
/gsd-discuss-phase 1
↓
/gsd-plan-phase 1
↓
/gsd-execute-phase 1
↓
/gsd-verify-work 1
/gsd-map-codebase to understand the existing repositories, structure, and relationships before making changes. Then follow the GSD workflow: Discuss → Plan → Execute → Verify./gsd-map-codebase
↓
/gsd-discuss-phase 1
↓
/gsd-plan-phase 1
↓
/gsd-execute-phase 1
↓
/gsd-verify-work 1
↓
/gsd-progress
Tip: If you want to explore the GSD commands available in your Claude Code environment, use the /help command. It provides information about the available commands and how to use them.
Skills — How Skills Help Claude
Another important part of our setup is skills. Skills provide reusable instructions and context that help Claude follow project-specific conventions, such as coding standards, testing, validation, architecture, and documentation.
Combined with GSD, they help Claude work more consistently across different types of development tasks, especially in a larger codebase.
Skills can cover different types of development work, such as research, planning, implementation, testing, code review, debugging, and documentation. The available skills depend on your project setup.
The important point is that skills don't remove the need for developer judgement. They help provide structure and consistency, while the developer remains responsible for the final outcome.
What Claude Code Can Do
Claude Code can help with codebase analysis, planning, implementation, testing, debugging, code review, and documentation.
For enterprise applications, the key benefit is its ability to understand existing code across multiple repositories and work within the project's context, helping developers make changes faster while maintaining existing architecture and standards.
Developer in the Loop — Supervision and Validation
This is probably the most important part of using AI for software development.
AI can accelerate development, but the developer should remain in the loop.
Claude can explore the codebase, create plans, modify code, and run tests. But we still need to review whether it understood the requirement, followed the existing architecture, made the right changes, and covered the necessary tests. A passing test does not always mean the implementation is correct. AI can misunderstand business requirements or make assumptions that don't fit the system.
Our approach is therefore not:
Requirement → AI → Final Code
Instead:
Requirement → AI → Developer Review → Implementation → Validation → Approval
The developer remains responsible for the final technical decisions and quality of the software.
Our Practical Workflow
- Understand — Start with the requirement and provide the necessary context.
- Explore — Let Claude understand the relevant repositories, code, dependencies, and existing implementation.
- Plan — Create and review the implementation plan before making changes.
- Implement — Claude makes the required changes across the relevant files or repositories.
- Test — Run tests, investigate failures, and fix issues.
- Review & Refine — Review the Git diff and overall implementation, then refine if needed.
This gives us an iterative process where AI does the heavy lifting, while the developer stays in control.
Real Development Example
For a real task in our project involving schema tracking and lineage, we used Claude across multiple repositories to understand the existing implementation, plan and implement the changes, and validate the results.
For the lineage UI, we used React Flow to visualize the relationships between datasets and components.
This is where GSD + skills + developer supervision helped us move faster while keeping the developer in control.
The screenshots below are from our actual development environment, with project-specific information removed or anonymized where required.
Sample Lineage graph1
Sample Lineage graph2
What Worked Well and What to Watch
What Worked WellClaude Code has been especially useful for understanding code, working across repositories, planning, coding, testing, and debugging.
The biggest benefit is saving time across the development cycle and getting to the solution faster.
What to Watch
AI can hallucinate, misunderstand requirements, introduce bugs, make unwanted changes, over-engineer solutions, or create tests that don't fully validate the requirement. Clear instructions, developer supervision, review, and validation are therefore essential.
