Generative Software Development: From Coding to Conversing
As someone who's spent the better part of my career deep in distributed systems - debugging memory issues at 3 a.m., obsessing over database consistency models, and chasing every last bit of performance– I never thought I'd see the day when writing code would feel conversational.
I don't write production code daily anymore. My role as a CEO is different now: strategy, team-building, and product vision consume most of my day. But the developer in me watches this transformation with awe. We're not just improving developer tools. We're redefining how software is built.
Let's trace a path through the AI tools I've used through my career, and how we're collaborating with AI at Tigris.
From Autocomplete to AI Partners
Back in the late '90s, IntelliSense was revolutionary. Introduced by Microsoft in 1996, it cut down on repetitive keystrokes and made exploring APIs easier. It wasn't "intelligent" in the way we talk about intelligence today, but it did reduce documentation lookups significantly.
Fast-forward 30 years, and we're no longer just talking about keystroke savings. We're talking about AI partners, tools that understand intent, design systems, and even debug complex workflows. The jump from IntelliSense to GitHub Copilot, to Cursor, and now to Claude Code, isn't incremental. It's exponential.
The Four Generations of Developer Assistance
If I map out my own experience with these tools, I see four clear generations:
IntelliSense Era
- Pattern matching & static analysis
- Single-file context awareness
- 20-30% keystroke reduction
AI Revolution (Copilot)
- Large language models (Codex/GPT)
- Multi-file context
- 35-55% faster development
AI-Native IDEs (Cursor)
- Project-wide understanding
- Multi-model flexibility
- Lower latency than Copilot
Prompt-Based Development (Claude Code or GPT-5 via Codex CLI)
- Autonomous task execution
- Natural language programming
- Complete workflow automation
What strikes me most is not the raw capability improvements, but the shift in how developers think about code. We've gone from "type less" to "describe what you want."
The Turning Point: GitHub Copilot
Copilot was my first real taste of AI, writing code that felt like my own. I still remember asking it to generate a Terraform module for Tigris, our S3-compatible object storage, and watching it produce over 2,000 lines of code in minutes.
The 1,000 lines of enhancements added to the Tigris Terraform Provider.
Was it perfect? Of course not. I had to review and make 1,000+ lines of enhancements before shipping. But that didn't matter. It turned a multi-day task into something I could iterate on in an afternoon.
Copilot made me realize something fundamental: developers are now curators and reviewers as much as they are authors of code.
Cursor: The IDE Redefined
If Copilot felt like autocomplete on steroids, Cursor feels like hiring a junior engineer who can read and understand the entire repository in seconds.
I recently used Cursor while working on our object storage cache for PyTorch and Dask. I'd describe a design or a feature, "optimal file reading that uses the cached file handler", and Cursor would produce a usable draft across multiple files.
It wasn't about typing anymore. It was about guiding. I found myself shifting from "what code do I write?" to "how do I architect this system, so AI can fill in the details?"
Claude Code: The Prompt Revolution
By the time I had gotten comfortable with tools like Copilot and Cursor, I thought I had a pretty good sense of what "AI-assisted development" could do. Then I tried Claude Code.
Claude Code takes it one step further. It's not just embedded in an IDE; it's like an autonomous copilot. Combined with Conductor, I can run multiple Claude agents in parallel. I first used Claude on tigrisfs, our FUSE-based filesystem that mounts S3-compatible object storage as a local POSIX drive. This is deep infrastructure code, definitely not low-hanging fruit.
With a single command:
$ claude "Replace deprecated semaphore implementation"
Claude scans the tigrisfs repo, finds the outdated code, implements a fix, tests it, and opens a pull request with a detailed explanation.
The wild part? That PR is then reviewed by another AI agent: Copilot. Claude takes the feedback, updates the code, and resubmits.
Another AI reviews the AI generated code, leaves nitpick comments, which are then resolved by Claude.
This wasn't just code generation. It was multi-step task execution, contextual understanding, and collaborative iteration - all initiated from a single prompt.
This is where things clicked for me: we're no longer just writing code with AI's help. We're supervising autonomous agents as they do the heavy lifting.
The Future: From Coding to Conversing
We're entering a new phase of Conversational Development. Code is still involved, but the interaction layer is now natural language. Here's where I think we're heading:
- 50%+ of new code written by AI
- IDE → AI orchestration platform
- Developers focus on architecture, validation, and system thinking
- Prompt engineering becomes a core competency
We're not just witnessing a new generation of developer tools. We're witnessing a redefinition of what it means to be a software engineer.
As a founder, this excites me. I see the potential to build faster, iterate more intelligently, and remove the friction that slows innovation. But it also demands a mindset shift.
Those who don't embrace this transformation will likely get left behind. At Tigris, we're building the storage layer designed for the future of AI.
Want to explore how we’re building infrastructure to support this future?
Tigris is object storage purpose-built for AI workloads