The Product Manager Is Dead. Long Live the Product Developer.
The person who walks into the room with Figma mockups and says 'build this' has run out of runway. AI collapsed the d...
When AI Becomes Your Thinking Partner
8 min read
Working With AI, Not Just Using It
20.03.2026, By Stephan Schwab
Most developers use AI as a glorified autocomplete. The real power comes when you stop asking for solutions and start having conversations about problems. A migration story shows how agentic AI collaboration transforms complex technical work from solo debugging into guided discovery.
The Difference Between Tools and Partners
I needed to migrate a newsletter service from one Kubernetes namespace to another. Different databases, different ingress configurations, certificate management, zero downtime requirements — the kind of work that usually involves reading documentation, making mistakes, and fixing them later.
Instead of diving in, I opened a conversation with GitHub Copilot.
Not “write me a migration script.” Not “how do I move data between namespaces.”
A conversation.
Me: “I need to route newsletter.example.com to the newsletter app in app-staging. Currently it points to newsletter-prod. Different namespaces, need to merge databases first.”
Copilot: “Let me understand the current state. What’s in each namespace?”
That question changed everything.
The Shape of Agentic Collaboration
"Agentic AI doesn't give you answers. It asks better questions than you thought to ask yourself."
Most AI interactions follow a pattern: you ask, it answers, you implement. Sometimes it works. Often you’re back asking follow-up questions because the answer missed context.
Agentic collaboration inverts this. The AI asks clarifying questions. Suggests approaches. Points out risks you haven’t considered. Forces you to articulate assumptions you didn’t know you were making.
Copilot: “Before we start moving data, what’s the record count in each database? We need to know if there are conflicts.”
I hadn’t thought about conflicts. I was focused on the migration mechanics.
sqlite3 production.db "SELECT COUNT(*) FROM subscribers"
# 343
sqlite3 staging.db "SELECT COUNT(*) FROM subscribers"
# 315
Me: “Production has 343 subscribers, staging has 315. Looks like some overlap.”
Copilot: “The staging database is newer but has fewer subscribers. That suggests production has the authoritative data. But staging has x_credentials and queued_posts that production doesn’t. We’re not just migrating — we’re merging two divergent datasets.”
Now we’re getting somewhere.
Dialog Reveals Hidden Complexity
If I’d asked for a migration script, I’d have gotten one. It would have copied data. Probably would have worked. Might have lost 28 subscribers in the process.
The conversation surfaced what the problem actually was: two databases with different purposes, evolved separately, now being unified. The newsletter tables belonged to production. The social media tables belonged to staging. The migration wasn’t moving everything — it was selectively preserving each system’s authoritative data.
Copilot: “Here’s what I’m thinking:
- Export newsletter tables from production (subscribers, send logs, digest settings)
- DELETE those tables in staging (they’re stale)
- Import production’s newsletter data
- Keep staging’s x_credentials and queued_posts intact
- Verify the merged database locally before touching the cluster”
Me: “Makes sense. What about the actual database swap?”
Copilot: “Scale deployment to zero, mount the PVC through a helper pod, backup the existing database, copy the merged one in, delete the helper pod, scale back up. Standard pattern — but we should test the merged database locally first. If something’s wrong, we catch it before production is affected.”
This is the value of agentic AI. Not just generating code. Suggesting a workflow that includes verification steps. Anticipating failure modes.
The Commands Write Themselves
Once the approach was clear, the implementation was straightforward. Copilot generated the export commands, the merge script, the kubectl operations. Not because it’s a better command generator than documentation — because the conversation had clarified exactly what needed to happen.
# Export from production
sqlite3 production.db ".dump subscribers" | grep "^INSERT" > /tmp/export_subscribers.sql
sqlite3 production.db ".dump newsletter_send_log" | grep "^INSERT" > /tmp/export_send_log.sql
# Create merge script
cat > /tmp/merge.sql << 'EOF'
DELETE FROM subscribers;
DELETE FROM newsletter_send_log;
EOF
cat /tmp/export_subscribers.sql >> /tmp/merge.sql
cat /tmp/export_send_log.sql >> /tmp/merge.sql
# Apply to local copy
cp staging.db merged.db
sqlite3 merged.db < /tmp/merge.sql
# Verify
sqlite3 merged.db "SELECT 'subscribers', COUNT(*) FROM subscribers
UNION ALL SELECT 'x_credentials', COUNT(*) FROM x_credentials"
Expected output: 343 subscribers, 4 x_credentials. Got it.
Me: “Local merge verified. 343 subscribers, 4 x_credentials. Ready for cluster push.”
Copilot: “Good. Now we scale down the deployment, mount the PVC through a temporary pod, backup the existing database, copy the new one in, and scale back up. Here’s the sequence.”
No guessing. No trial and error. The conversation had established confidence.
When Ingress Configuration Gets Interesting
"The code is the easy part. The hard part is knowing what code to write. Agentic AI helps you think through the what before you write the how."
With the database migrated, the next step was switching the DNS routing. Remove the ingress from newsletter-production, create it in app-staging, update the TLS certificate reference.
Me: “Database is live in app-staging. Now I need to move the ingress.”
Copilot: “Two ingress resources — one for HTTPS (websecure entrypoint), one for HTTP redirect. The redirect needs a middleware to force HTTPS. Also update BASE_URL environment variable in the deployment so the app generates correct links.”
I’d forgotten about the BASE_URL. The app would have worked, but every email link would have pointed to the old staging URL. Users would have been confused. The AI caught it.
That’s not intelligence. That’s pattern recognition across thousands of similar configurations. But in the moment, it’s indistinguishable from a senior developer reviewing your plan.
The Rollback Plan You Hope Never To Use
Copilot: “Before you apply those ingress resources, let’s document the rollback procedure. If something breaks, you want the commands ready.”
Smart.
# Rollback if needed
kubectl delete ingress newsletter-prod newsletter-prod-redirect -n app-staging
kubectl set env deployment/newsletter -n app-staging BASE_URL=https://newsletter-staging.example.com
kubectl scale deployment newsletter -n newsletter-prod --replicas=1
helm upgrade newsletter ./helm/newsletter -n newsletter-prod
We didn’t need it. But having it written down before the migration reduced the stakes. If anything went wrong, recovery was three commands away.
What Agentic AI Actually Means
Agentic AI isn’t about agents running autonomously. It’s about AI that participates in problem-solving instead of just responding to requests.
It asks clarifying questions. Suggests verification steps. Points out edge cases. Keeps track of the plan while you focus on execution.
You’re still driving. But instead of navigating alone, you have someone reading the map, watching for exits, reminding you where you’re going.
The migration took 40 minutes. No errors. No rollback needed. The newsletter went out the next day to 343 subscribers from the new namespace.
Would I have figured it out without AI? Of course. Would it have taken longer? Probably. Would I have remembered to update the BASE_URL before deploying? Maybe not.
How To Work This Way
"The best AI collaboration feels like pair programming with someone who's seen this problem before — not because they're smarter, but because they've indexed more failures."
If you want AI to be a thinking partner instead of a command generator:
Stop asking for solutions. Start describing problems.
Not “write a script to migrate data” — “I need to merge two databases with overlapping schemas.”
Respond to questions instead of ignoring them.
When Copilot asked about record counts, I could have dismissed it. Copilot ran the queries as asked. That context shaped everything after.
Treat the conversation as a design session.
You wouldn’t hand a colleague a task and walk away. You’d discuss approach, risks, edge cases. Same here.
Verify locally before touching production.
The AI suggested this. It’s good practice whether AI is involved or not. But having it prompted in context meant I actually did it.
Keep the conversation focused on one problem.
Jumping between topics confuses the AI’s context window. Finish the migration before asking about unrelated infrastructure.
The Future Is Already Here
This wasn’t experimental technology. GitHub Copilot. In VS Code. Available to anyone with a subscription.
The difference isn’t the tool. It’s how you use it.
Most developers use AI for autocomplete. Generate a function. Fix a bug. Write boilerplate.
That’s fine. Autocomplete is useful.
But agentic collaboration — using AI as a thinking partner — changes the nature of technical work. You’re not coding alone anymore. You’re working with something that has pattern recognition across millions of repositories and can articulate what it sees. As I wrote in Beyond the Solo Developer Myth, the best work happens in collaboration. AI just adds another form of it.
It doesn’t replace experience. But it makes experience more accessible. The gray beard discovers the machine isn’t competition — it’s amplification.
A junior developer with good questions can get senior-level guidance. A senior developer can move faster without sacrificing thoroughness.
The constraint isn’t the AI. It’s whether you’re willing to have a conversation instead of just asking for answers.
Why This Matters For Teams
Individual productivity improvements are nice. Team-level implications are more interesting.
Knowledge distribution becomes easier.
That migration? I could have done it alone. But explaining it to Copilot meant articulating the approach clearly. That clarity translates when I need to explain it to a colleague.
Documentation writes itself.
The conversation became the migration plan. I saved the transcript. Next time someone needs to merge databases and switch ingress, the pattern is documented — not as abstract steps, but as a real conversation about real tradeoffs.
Onboarding gets faster.
New team members can point AI at the codebase and ask questions. “What does this service do?” “Where does authentication happen?” “Why are there two database connections?” Instead of hunting through wikis or waiting for a senior developer to be free, they get immediate, context-aware answers grounded in the actual code. Not perfect answers. But good enough to form the next question.
Technical debt becomes more visible.
When you explain a system to AI, inconsistencies surface. “Why are there two databases?” becomes a question you can’t handwave away.
This isn’t replacing senior developers. It’s making senior development patterns more accessible to everyone.
The constraint shifts from “do we have someone who knows how to do this?” to “can we articulate what we’re trying to do?” When coding is no longer the bottleneck, the ability to think clearly about problems becomes the competitive advantage.
That’s a better constraint.
The Migration Nobody Noticed
Newsletter went out Friday morning. 343 recipients. No bounces. No downtime. No emergency messages.
From a user perspective, nothing changed. From an infrastructure perspective, everything changed.
That’s the goal.
The AI didn’t do the migration. I did. But the AI made it easier to think through, safer to execute, and simpler to verify.
Agentic collaboration isn’t about automation. It’s about augmentation.
You’re still responsible. Still making decisions. Still writing code.
But you’re not doing it alone anymore.
And that makes all the difference.
Contact
Let's talk about your real situation. Want to accelerate delivery, remove technical blockers, or validate whether an idea deserves more investment? I listen to your context and give 1-2 practical recommendations. No pitch, no obligation. Confidential and direct.
Need help? Practical advice, no pitch.
Let's Work Together🎭 This Week's Episodes
Telenovelas show what we can't say in client meetings. The drama is heightened, but the patterns are real.
La Verdad
The emergency board meeting Don Hernando demanded has arrived. Mariana and the Vulcano Capital team want answers. Alejo has one final card to play....
When Players Revolt
They fixed the validation bug properly — six hours, no corners cut. But the database migration script Anton wrote Monday night to handle legacy NUL...
Technical Consultancy
Senior Developer Advocate
Embedded into your team as an active contributor, increasing effectiveness and elevating engineering clarity.
Technical Advisor
Peer-style technical assessments before far-reaching decisions; reduce architectural and product risk early.
Product & Delivery
Ship working software to real users earlier. Measure impact and adapt based on evidence rather than assumption.
Custom Software Development
High quality, maintainable software. Short-term augmentation that leaves lasting capability in your own team.
Recent Articles
- When Labor Becomes Cheap, Motivation Becomes Everything (06.04.2026)
- Authentication Methods That Work in 2026 (03.04.2026)
- Developer, Not Engineer. And Why It Matters (30.03.2026)
- The Product Manager Is Dead. Long Live the Product Developer. (27.03.2026)
- Building Products in the Age of AI (23.03.2026)