How We Use AI in Our Software Development Process
LTrands Editorial Team
Published April 20, 2026
This post is a detailed walkthrough of how AI fits into our actual development workflow. No hype, just what works and what doesn't.
Our AI Stack
Before diving into the workflow, here are the tools we use:
- Cursor and Claude: For code generation, refactoring, and debugging. We use Claude for large architectural discussions and Cursor for in-editor code completion and generation.
- GitHub Copilot: Used alongside Cursor for inline completions and boilerplate generation.
- ChatGPT and Claude (chat interfaces): For brainstorming architecture, writing documentation drafts, generating test cases, and rubber-duck debugging.
- Custom scripts: We've built internal CLI tools that call LLM APIs for batch tasks like generating CRUD endpoints, converting database schemas to TypeScript types, and creating migration files.
We don't use a single "AI platform." We use whatever tool fits the task best, and we switch between them constantly throughout the day.
Stage 1: Planning and Architecture
How We Used to Plan
Before AI, planning a new feature or product involved:
1. The lead engineer writes a technical spec document (2–4 hours)
2. The team reviews it in a meeting (1 hour)
3. Revisions are made (1–2 hours)
4. Tasks are broken down and assigned (1 hour)
Total: 5–8 hours before anyone writes a line of code.
How We Plan Now
We start by writing a rough feature description — bullet points, user stories, constraints — and feed it to Claude or ChatGPT. The AI generates a detailed technical spec with:
- Architecture overview: Recommended stack, data flow diagrams in text, API route structure
- Database schema: Tables, relationships, indexes, migration notes
- Component tree: For frontend features, a breakdown of components, props, and state management
- Edge cases: The AI is surprisingly good at listing edge cases we might miss — empty states, error states, loading states, permission boundaries
- Testing strategy: Unit, integration, and E2E test suggestions with specific scenarios
This first draft takes about 30 seconds to generate. A senior engineer then spends 45–60 minutes reviewing, correcting, and refining it. The result is a spec that's 80–90% complete, produced in under an hour.
What we learned: The AI spec is never production-ready on the first pass. It makes assumptions about our existing codebase that are wrong. It suggests patterns that don't match our conventions. But it gives us a solid starting point that saves 3–4 hours per feature.
A Real Example
When we built the multi-tenant architecture for Webbing.cloud, we fed Claude this prompt:
> We're building a multi-tenant e-commerce platform. Each tenant has their own store, products, orders, and customers. Tenants share the same database but data must be strictly isolated. We use PostgreSQL, Next.js, and Prisma. Generate a database schema, API route structure, and middleware approach for tenant isolation.
Claude produced a comprehensive design with row-level security policies, a tenant-aware middleware pattern, and Prisma schema extensions. We spent two hours refining it instead of two days writing it from scratch.
Stage 2: Scaffolding and Boilerplate
This is where AI saves the most time — and where it's the least controversial.
Project Setup
Starting a new Next.js project with our standard stack (TypeScript, Tailwind, Prisma, NextAuth, tRPC or REST, testing setup) used to take a full day. Now we have a prompt template that generates the entire scaffold:
- `package.json` with all dependencies
- `tsconfig.json` with our standard settings
- Tailwind config with our design tokens
- Prisma schema with common models (User, Session, etc.)
- Auth configuration
- Folder structure following our conventions
- CI/CD pipeline config (GitHub Actions)
- ESLint and Prettier configs
We run the prompt, review the output, adjust anything that doesn't match our latest conventions, and we're done in 30 minutes.
CRUD Operations
For internal tools and admin panels, we generate entire CRUD stacks:
1. Prisma model → AI generates the schema
2. API routes (GET, POST, PUT, DELETE) with validation → AI generates
3. React form components with react-hook-form + zod → AI generates
4. Table/list components with sorting and pagination → AI generates
A typical admin CRUD page that would take 3–4 hours to build manually now takes 30–45 minutes. The generated code follows our patterns because we include examples in the prompt.
The Key to Good Scaffolding Output
The quality of AI-generated code is directly proportional to the quality of your prompt. We've learned to include:
- Context about existing code: "Here's our existing User model. Generate a Post model that relates to it."
- Convention examples: "Use the same pattern as src/app/api/users/route.ts"
- Specific constraints: "Use Zod for validation, follow our error response format, add proper HTTP status codes"
Vague prompts produce vague code. Specific prompts produce code that needs minimal changes.
Stage 3: Feature Development
Pair Programming with AI
During active development, we use Cursor and Copilot as always-on pair programmers. Here's what that looks like in practice:
Inline completions: Copilot suggests the next few lines based on context. This is most useful for repetitive patterns — mapping over arrays, writing switch cases, filling in JSX structures. We accept about 60–70% of Copilot's suggestions.
Multi-file refactoring: Cursor's agent mode can make changes across multiple files. For example, "Rename the `user` field to `createdBy` across all API routes and components." It finds every reference, updates imports, and adjusts types. We review every change before committing.
Debugging: When we hit a bug, we paste the error message and relevant code into Claude. It identifies the issue faster than we can manually trace through stack traces. Common debugging prompts:
- "This Prisma query is returning unexpected results. Here's the schema, the query, and the actual vs expected output."
- "This React component is re-rendering infinitely. Here's the component and its parent."
- "This API route is returning a 500 error. Here's the route handler and the error log."
Claude solves about 70% of bugs on the first attempt. For the other 30%, it at least narrows down the problem area.
Writing Tests
We use AI to generate test cases, but we never ship AI-generated tests without review. Here's our process:
1. Write the implementation
2. Feed the implementation + spec to AI: "Generate comprehensive unit tests for this function. Cover happy path, edge cases, error states, and boundary conditions."
3. Review the generated tests:
- Does each test actually test something meaningful?
- Are the assertions correct?
- Are there any tests that would pass even if the code is broken?
4. Add tests the AI missed (usually business-logic-specific edge cases)
5. Run the test suite and fix any that fail
The AI generates about 60–70% of useful test coverage. The remaining 30–40% requires human judgment about what's important to test in the context of the business domain.
Writing Documentation
Every PR at LTrands requires updated documentation — API docs, README updates, changelog entries. AI handles the first draft of all of these:
- API documentation: Feed the route handler to AI → it generates OpenAPI-style docs with request/response examples
- README updates: Describe the feature → AI updates the relevant sections
- Changelog: Summarize the PR → AI generates a changelog entry following our format
Documentation drafts take 2–5 minutes instead of 20–30. A human reviews for accuracy and tone before merging.
Stage 4: Code Review
AI-Assisted Review
Before a PR goes to a human reviewer, it goes through an AI review. We use a script that:
1. Takes the PR diff
2. Sends it to Claude with our review guidelines
3. Claude flags:
- Potential bugs (null checks, race conditions, error handling gaps)
- Security issues (SQL injection risks, missing auth checks, exposed secrets)
- Performance concerns (N+1 queries, missing indexes, unnecessary re-renders)
- Style violations (naming conventions, file structure, import order)
- Missing tests for critical paths
The AI review catches about 40% of the issues we'd normally catch in human review. More importantly, it catches them before the human reviewer spends time on them, which makes human review faster and more focused on architectural concerns.
Important: We never auto-merge based on AI review. The AI flags things for human attention — it doesn't make decisions.
Where AI Falls Short
Being honest about the limitations is important. Here's what AI does poorly in our experience:
1. Understanding Business Context
AI generates code that's technically correct but wrong for the business. Example: "Generate a function to calculate invoice totals." The AI includes tax calculations, but it doesn't know that in our system, tax is calculated at the line-item level, not the invoice level. Human knowledge of business rules is irreplaceable.
2. Large-Scale Architecture
Ask AI to design a system with 50+ services, and it produces something that looks reasonable but falls apart under scrutiny. It doesn't understand organizational boundaries, team structures, deployment constraints, or legacy system integration. Architecture still requires experienced engineers.
3. Novel Problems
AI is great at problems it's seen before. If you're solving a genuinely novel problem — a new algorithm, an unusual integration, a unique UX pattern — AI suggestions are often generic and unhelpful. The rarer the problem, the less useful AI becomes.
4. Maintaining Consistency
AI generates code that's internally consistent within a single response, but across multiple prompts over multiple days, the patterns drift. Without careful prompting and review, AI-generated code leads to a fragmented codebase with inconsistent patterns.
5. Security Decisions
We never trust AI with security decisions. AI might suggest an authentication flow that looks reasonable but doesn't account for session fixation, CSRF, or timing attacks. Security architecture is always human-designed and human-reviewed.
Our Principles for AI-Assisted Development
After two years of integrating AI into our workflow, we've settled on these principles:
1. AI suggests, humans decide: Every line of AI-generated code is reviewed by a human. No exceptions.
2. Context is everything: The better the prompt (with codebase context, conventions, constraints), the better the output. Garbage in, garbage out.
3. AI is a junior engineer, not a senior architect: We treat AI like a highly productive junior developer. It does the first draft quickly, then seniors review and refine.
4. Test everything AI generates: AI-generated code passes unit tests at the same rate as human-written code. But it sometimes passes tests for the wrong reasons. Human review of test assertions is critical.
5. Invest in your prompts: We maintain a shared library of prompt templates for common tasks (scaffolding, CRUD generation, test generation, documentation). These templates evolve as our conventions change.
6. Don't let AI drive the architecture: AI can suggest architectural patterns, but the final decisions are made by engineers who understand the full system context, business requirements, and long-term maintenance implications.
The Bottom Line
AI tools have made our team significantly more productive. Features that took a week now take days. PRs that took days now take hours. Documentation that was perpetually out of date now stays current.
But AI hasn't replaced any engineers. It's made each engineer more effective by eliminating the boring, repetitive parts of the job — boilerplate, documentation, test scaffolding, first-pass code review.
The engineers still do the creative, challenging work: designing systems, making architectural trade-offs, understanding user needs, and ensuring the final product is correct, secure, and maintainable.
If you're considering integrating AI into your development workflow, start small. Pick one stage (we started with test generation) and measure the impact before expanding. And remember: AI is a tool, not a strategy. The strategy is building great software, and that still requires great engineers.
*Have questions about our AI workflow? Want to discuss how this could apply to your team? [Reach out to us](#contact) — we're happy to share more details.*
LTrands Editorial Team
Our editorial team consists of expert software architects, fintech analysts, and AI researchers dedicated to exploring the intersection of technology and business efficiency.
