DEV Community: Sanket Gawas

The AI coding pattern spreading through engineering teams

Sanket Gawas — Sun, 27 Jul 2025 21:57:25 +0000

Most developers approach AI coding tools like magic wands, throwing vague instructions at them and hoping for optimal results. However, developers who consistently achieve excellent outcomes from AI follow a structured methodology.

The difference between vibe coding and structured AI development

Providing unclear instructions like "Hey Claude, can you make this payment flow better?"
Accepting whatever the AI suggests without proper context
Iterating through random solutions until something appears to work
Fighting the AI when it fails to understand your architecture

This pattern doesn’t scale. It increases PR churn, breaks layered ownership and confuses reviewers.

Structured AI Development on the other hand follows the Plan, Context, Execute, Review pattern

Lets walkthrough the 4 step process mentioned above with a refactoring example: “Refactor PaymentStrategy to support a new StripeV2Strategy, behind a feature flag.“

Step 1: Plan your approach

Before touching any AI tool, spend 5 minutes defining these three elements:

Specific goal

Bad: "Hey Claude, can you make this payment flow better?"
Good: "Refactor payment validation to use the new StripeV2 API while maintaining backward compatibility"

Success criteria

Bad: Vague hopes that "it works better"
Good: "All existing tests pass, new validation rules applied, error handling improved"

Clear constraints

Bad: No boundaries mentioned
Good: "Cannot modify the PaymentController interface, must support both old and new webhook formats"

Copy this planning template:

=== PLANNING TEMPLATE ===

Objective:
[Specific technical goal in one sentence]
Success Criteria:
[Measurable outcome 1]
[Measurable outcome 2]
[Measurable outcome 3]
Constraints:
[Technical limitation 1]
[Integration requirement 1]
[Performance/security requirement 1]

This 5 minute investment prevents the “AI slop” iterating through random solutions....

Step 2: Engineer your context

This is where most developers fail spectacularly.

The wrong way: Dumping your entire codebase into the AI

The right way: Providing strategic, targeted context

Context engineering formula

Instead of overwhelming the AI with everything, use this structure:

=== CONTEXT TEMPLATE ===

Files to Include:

[file-path] (specific line numbers if relevant)

[related-file] (reference for context)

[new-file] (if creating something new)

Domain Notes:

[Business logic constraint 1]

[Technical dependency 1]

[Integration requirement 1]

Security/Performance Constraints:

[Security requirement]

[Performance requirement]

[Logging/monitoring requirement]

Example for our PaymentStrategy refactor

Current architecture:
PaymentService handles validation (src/services/payment.ts:45-120)
StripeAdapter wraps API calls (src/adapters/stripe.ts)
Validation rules in PaymentValidator (src/validators/payment.ts:30-85)

Domain Notes:
StripeV2Strategy must support async webhook payload verification
Retry policies configured globally in retryConfig.ts
Customer object includes nested billing metadata requiring flattening

Security Constraints:
Stripe secret keys injected via Vault-backed config
Payment logs must redact PII using logger.redactFields utility

Pro tip: Point to specific functions and line numbers instead of entire files. Quality beats quantity every time....

Step 3: Execute with checkpoints

Never attempt large refactors in one shot. Break them into stages with verification points.

The Staged execution pattern

Stage 1: Add new components alongside existing ones
Stage 2: Update core logic with feature flags
Stage 3: Migrate dependent systems
Stage 4: Remove legacy code after verification

Example prompts for our refactor (Copy and amend these)

Prompt 1: Generate New Strategy

Create a new StripeV2Strategy class implementing the PaymentStrategy interface. It should:

Initialize using config-driven credentials from configManager.getStripeV2Config()

Implement validatePayment() using the new Stripe v2 /verify endpoint

Log validation events via structuredLogger.payment.v2.validate

Support fallback error modes for transient Stripe outages (400 vs 500 handling)

Prompt 2: Feature gate Integration

Update PaymentStrategyFactory to:

Read enable_stripe_v2_strategy from featureFlags.ts

Return StripeV2Strategy if flag is true, else fallback to StripeV1Adapter

Include metrics instrumentation via metrics.increment('payment.strategy.selected', { version: 'v2' })

Each prompt is laser-focused on one specific outcome. No ambiguity, no room for misinterpretation.

Step 4: Review systematically (Your quality gate)

This is where you’d spend most of your time reviewing for security, business logic, validation, error handling, logging, etc

Why this framework works?

Repeatable - Any engineer can follow the same pattern
Auditable - Easier to reason about diffs and test coverage
Safe - Interfaces, metrics, logs and rollback are all considered
Reusable - Turn these into prompt libraries and templates across teams

Thanks for reading

======================
I'm Sanket, helping developers keep up with AI dev tools, latest insights and tips delivered straight to your inbox- TheAIStack.dev

Claude Code's features that most developers never use

Sanket Gawas — Thu, 24 Jul 2025 21:23:08 +0000

Claude Code represents Anthropic's approach to bringing AI assistance directly into your terminal while maintaining deep integration with your development environment. While most developers use it for basic chat interactions, the platform includes advanced features that can fundamentally change how you approach software development.

This week I explored the lesser known capabilities that separate casual users from developers who have transformed their entire workflow. Some of these techniques I use daily, others I discovered through research and other dev communities. Here are the methods that can deliver the most significant productivity improvements.

Essential Setup Techniques

Create project memory with /init

The /init command scans your entire project structure and generates a CLAUDE.md file that serves as persistent memory. This file gets automatically included in every conversation, ensuring Claude maintains understanding of your project architecture, dependencies and established patterns.

Enable IDE integration with /ide

When working inside Cursor or VS Code, the /ide command establishes bidirectional connection between your editor and Claude. This integration allows Claude to reference files you have open or selected in your IDE. Claude Code supports Visual Studio Code (and forks like Cursor, Windsurf) and JetBrains IDEs (including IntelliJ IDEA, PyCharm, Android Studio, WebStorm etc)

Advanced Context Management

Strategic conversation management with /compact

When conversations become lengthy, most developers start fresh sessions and lose valuable context. The /compact command preserves conversation essence while clearing unnecessary details. It maintains previous decisions and nuances while freeing context space for new interactions.

Complete reset with /clear

Unlike compacting, the /clear command completely resets your conversation while re injecting your CLAUDE.md project file. Use this approach when switching between different features or debugging sessions where you want fresh perspective while maintaining project understanding.

Optimize file referencing with @

Replace full file path typing with the @ symbol followed by your filename. Tab completion makes this incredibly efficient. @auth.ts instantly references your auth file and Claude understands you want to work with that specific component.

Visual debugging

Take screenshots of errors, UI problems, or system states, then paste them directly into Claude Code using Ctrl+V. Claude Code can analyze visual information and provide contextual solutions. This proves particularly valuable for debugging complex interface issues or infrastructure problems.

Pro Level Automation

Interaction modes via Shift+Tab

Press Shift+Tab to cycle through different interaction modes. Auto-accept mode eliminates most permission prompts, allowing Claude to write files, change directories, and execute commands without constant interruption. Plan mode prevents file writing and focuses on conversation and architectural planning.

Custom commands for workflow automation

Create custom slash commands by adding Markdown files to .claude/commands. The first line becomes the command description, and the entire file content becomes the prompt template. Use $arguments to pass parameters. Store commands in ~/.claude/commands for global access or .claude/commands within specific projects for team collaboration.

Workflow automation through hooks /hooks

Hooks in your .claude/settings file trigger actions at specific workflow moments and make the agent more deterministic. This feature enables sophisticated workflow automation that most developers never discover.

/hooks are really powerful

External scripting integration

Claude Code functions as a command line utility within other scripts and automation systems. Use headless mode (claude -p) for programmatic integration and automation in other scripts. You can also combine Claude with other command line tools using Unix pipes and JSON output for structured responses.

Yolo mode

The claude --dangerously-skip-permissions command eliminates all confirmation prompts, allowing completely autonomous operation. While this enables unattended workflow execution, it requires careful consideration of security implications and should be used only in controlled environments.

=================
I'm Sanket, helping developers keep up with AI dev tools, latest insights and tips delivered straight to your inbox- TheAIStack.dev

The AI tool no one talks about is secretly winning

Sanket Gawas — Tue, 22 Jul 2025 21:18:43 +0000

I've spent the past month diving deep into developer subreddits, dev forums and youtube playlists to uncover what developers think about AI coding tools. The landscape is more quality driven and fragmented than most analyses suggest with some surprising winners and notable disappointments.

About This Sentiment Analysis

This analysis synthesizes feedback from 100+ sources including Reddit discussions, GitHub issues, developer testimonials and community forums, weighted across technical performance, adoption patterns, pricing concerns and platform specific limitations. The sentiment scores reflect general web sentiment patterns rather than definitive market positions.

I'll be sharing the detailed criteria, weighting methodology and source breakdown in upcoming issues. Consider this a snapshot of July 2025 developer sentiment.

Dev AI agent sentiments as of July 2025

CLI Agents: The Terminal Power Struggle

Claude Code: The expensive gold standard

Sentiment: Love hate relationship

Claude Code maintains its position as the technical leader, but the cost barrier is real. Developers consistently report superior code quality and architectural thinking compared to alternatives, but the gap between the low tier and max tier plans create genuine friction.

"Claude Code is expensive, reckless, and weirdly fun" captures the developer sentiment perfectly. It's the tool teams reach for when quality matters more than budget, particularly for complex autonomous coding tasks.

Gemini CLI: The free disappointment

Sentiment: Negative to mixed

This is where my initial research led me astray. Despite Google's generous free tier offering, developer sentiment around Gemini CLI is surprisingly negative. Multiple users including myself describe it as painfully slow with numerous bugs and a tendency to get caught in repetitive loops. You can read my past report on Gemini CLI here.

The quality gap with Claude Code is significant enough that developers continue paying for Claude despite Gemini CLI being free.

IDE Agents: Integration Wars

Cursor: The dethroned king facing crisis

Sentiment: Mixed to negative & major pricing backlash

Cursor is experiencing a significant user revolt and backlash over pricing and it could impact the platform's future. The pricing changes triggered widespread developer anger, "Bye Bye, Cursor. When Great Tools Turn Greedy" represents a common sentiment. Users report costs jumping from $50/month to $250/month for identical usage patterns, with some claiming forceful migration of Pro plans without consent.

GitHub Copilot Agent: The steady veteran

Sentiment: Stable positive

GitHub Copilot maintains steady positive sentiment through reliable performance and predictable pricing. The $10/month pricing remains attractive compared to Cursor's $20-44+ pricing tiers and the deep GitHub ecosystem integration provides genuine workflow advantages for teams already using Microsoft's development stack.

It is best for enterprise teams prioritizing stability and ecosystem integration over cutting edge features.

Amazon Kiro: The promising newcomer

Sentiment: Neutral to positive - Early but substantive

Amazon's Kiro focuses on addressing vibe coding problems through spec driven development, emphasizing documentation and planning.

Early testers report positive experiences with the structured development approach. The free preview tier during development is unusually generous for AWS, suggesting confidence in the product's long term viability.

OpenAI Codex: The ambitious platform with mixed execution

Sentiment: Mixed, trending cautiously positive

OpenAI Codex excels at handling multi task workflows and reducing context switching for experienced developers.

However the dev community is facing frustration on infrequent updates and slow bug fixes, with many developers feeling the project is neglected compared to rapidly evolving competitors. The $200/month Pro plan faces significant pushback, with many questioning whether current value delivery justifies the steep pricing compared to alternatives like Claude Code or Cursor.

Extension Agents: The specialized winners

Firebender: The android development champion

Sentiment: Positive, strong niche performance

Firebender represents a deep specialization in android development ecosystem. The community shows genuine enthusiasm "Best plugin for Android developers PERIOD!!!" and "Saved me so much time and my productivity is at 10x now" represent common developer testimonials.

4.9/5 stars in Android Studio marketplace, native android studio integration, Y Combinator backing with clear growth trajectory, used by engineers at major companies and it is quadrupling daily active users after Y Combinator launch.

JetBrains Junie: The Enterprise team champion

Sentiment: Strong positive - transparent and productive

Junie represents JetBrains' successful entry into agentic AI development with impressive metrics backing developer satisfaction. "Junie is slow... but absolutely great!" captures the developer sentiment perfectly. It also has a deep integration with IntelliJ IDEA, PyCharm, WebStorm, and GoLand.

Performance is the biggest pain point for this tool from the negative sentiments. The tool it excels at complex, multi step changes across large codebases but painstakingly slow.

=================
I'm Sanket, helping developers keep up with AI dev tools, latest insights and tips delivered straight to your inbox- TheAIStack.dev

Free vs Premium: Testing Google’s Gemini CLI against Claude Code

Sanket Gawas — Fri, 18 Jul 2025 10:01:56 +0000

Google released Gemini CLI three weeks ago which is a free, open source alternative to one of the most sophisticated AI development tools available Claude Code. For developers paying $20 min monthly for Claude Code, this presents a viable free option.

I spent two weeks testing both tools on identical projects to understand whether free can compete with premium in AI development.

The Challenge

I designed a test involving complete Postgres database layer implementation in a sample saas application which included schema design, sample data seeding, querying and indexing. I used the same context and instructions for the agents. I used Opus 4 for planning and Sonnet 4 for implementation while Gemini mostly used the 2.5 pro model and switched to 2.5 flash later on.

Overall Performance

Gemini CLI: Completed in 13 minutes with active guidance, Required more interactions to maintain consistency.

Claude Code: Completed in 7 minutes with minimal supervision, Required comparatively (~50%) less interactions.

Pricing

Gemini CLI: Free(ish) with generous limits (60 requests/minute, 1000/day).

Claude Code: $20 minimum monthly plan with limit resetting every 5 hours

Context Understanding

Gemini CLI:

1 million token context window (5x larger than Claude Code)
Built-in Google Search integration and MCP tools support
Multimodal capabilities for processing images, files, and diverse data types

Claude Code:

200k token context window but superior context compacting
Better architectural decision awareness
A plan mode adding to some deterministic nature
Few bugs and consistent reliability across sessions

Code Quality

Gemini CLI follows instructions literally, implementing exactly what you request. Output can feel quite basic but achieves core functionality reliably. Sticks precisely to specifications without creative additions.

Claude Code produces polished implementations. It applies current best practices in schema design, normalization, and data integrity, sometimes even suggesting improvements or optimizations beyond the initial prompt.

Pain Points

Gemini CLI:

Frequent rate limiting forces model downgrades (Pro to Flash)
Uses about 4 times as many tokens as Claude, which quickly erases its advantage of having a larger context window.
Gets stuck in implementation loops during complex tasks
Lacks dedicated project initialization commands
Defaults to outdated frameworks (Bootstrap vs Tailwind)
Unpredictable behaviour and difficulty recovering from tool failures
Issues understanding local image files as context

Claude Code:

Expensive subscription costs for heavy usage ($100 and $200 monthly plans)
Sometimes adds unwanted features without requests
Runs out of tokens quickly on the $20 dollar plan and have to wait for it to reset.

Assessment

After two weeks of intensive testing, here's my honest take: Gemini CLI is not there yet on the podium with Claude Code but it's free tier offers an incredible entry point to understand these workflows before investing in premium tools. I'd say it delivers ~60% of Claude Code's capabilities at zero cost. Claude Code still remains the king for reliability, stability and that intangible taste that makes code feel professionally crafted.

There's some hope

Within three weeks of launch, the GitHub repository exploded with activity, 146 pull requests, daily commits and a thriving community of contributors.

While Claude Code evolves at Anthropic's pace, Gemini CLI could catch up rapidly through community contributions. I'd say it will take some months to catchup with Claude and be competitive.

=================
I'm Sanket, helping developers keep up with AI dev tools, latest insights and tips delivered straight to your inbox- TheAIStack.dev