Forem: Nikul Pandya

I Automated My Morning Tech News with Claude — Here's What Worked (and What Didn't)

Nikul Pandya — Fri, 24 Apr 2026 14:10:44 +0000

Every morning, I used to spend about 30 minutes reading tech news before I wrote a single line of code.

AI releases. Azure updates. Python releases. GitHub changelog. React RFCs.

All in different places. All with the same stories re-reported by five different outlets.

I'd open 20 tabs, skim until my coffee got cold, and by lunchtime I'd forgotten half of it.

So I tried to fix it — and in doing so, hit three dead ends before landing on something that actually works.

This is that story.

The shift I was really after

I didn't want a better news reader.

I wanted news brought to me, already filtered, already deduplicated, waiting when I sat down.

Less "Claude, help me read the news."

More "Claude, read the news for me. I'll check what matters."

That distinction turns out to be the whole game.

What Claude Cowork actually is

For those who haven't tried it yet: Cowork is Anthropic's agentic layer on top of Claude Desktop.

It's not a chatbot.

It runs tasks on your machine with access to your files, your connected tools (Confluence, Outlook, SharePoint, web search), and — the important part — a scheduler.

You give it a prompt once. You pick an interval (hourly, daily, weekly). It runs on its own.

The whole thing is basically: Claude Code, but for everyday non-coding work.

What I ended up building

Three daily briefings, running 15 minutes apart every weekday morning:

Time	Briefing	Focus
9:00 AM	AI Pulse	Model releases, research papers, funding, regulation
9:15 AM	Cloud Pulse	Azure services, GitHub Copilot, Actions, security advisories
9:30 AM	Tech Stack Pulse	Python, TypeScript, React, Flask, FastAPI, VS Code

Each one writes directly to a rolling Confluence page.

Today's entry lands at the top. Anything older than 30 days is automatically deleted. The page never grows unbounded.

Total reading time on a good morning: about 5 minutes.

Why email was the obvious choice — and the wrong one

My first instinct was: just email it to me.

Both the Outlook and Gmail connectors exist. Both plug into Claude cleanly. Problem solved, right?

No.

Both are read-only by default. They can search your inbox, they can draft emails, but they cannot send on your behalf. This is deliberate — Anthropic ships these connectors with write permissions locked down to prevent an agent from accidentally mailing every contact you have.

Which is the right call. But it kills the "daily digest arrives in my inbox" pattern dead.

The third-party workaround (and why I skipped it)

There are workarounds.

Services like Composio offer hosted MCP servers with full send capability. They're SOC 2 certified. Real company. Reasonable choice for many.

But you're handing a new vendor OAuth access to your mailbox. That's a genuine security decision, not a checkbox.

I evaluated it honestly and decided:

For a non-critical mailbox and a personal digest — fine
For a work account with anything remotely sensitive — not worth it

So I went looking for a tool I already trusted.

The unexpected winner: Confluence

Our Atlassian connector can read and write pages.

No new vendor. No extra OAuth grant. No IT approval cycle. Just a connector that was already there, trusted, audited.

And honestly? Confluence turned out to be a better destination than email:

Searchable — six months from now I can find the story I vaguely remember
Archivable — the 30-day window keeps things tidy
Accessible from anywhere — laptop, mobile app, web
No inbox clutter — a daily email slowly becomes noise; a page stays a page

Sometimes the best tool is the one you already have.

The prompt architecture that makes it work

A naive "get me 5 AI stories each morning" prompt produces noise within a week.

The same story gets re-covered by three outlets. A launch from Tuesday shows up again on Thursday under a different headline. You stop reading.

Four design decisions fix this:

1. Dedup against your own history.

Before searching the web, Claude reads the last 14 days of your own Confluence page. It builds an "already-seen list" of covered subjects — then skips anything already briefed.

2. Subject-level matching, not headline-level.

"Anthropic launches Opus 4.7" and "Opus 4.7 benchmarks impress" are the same story. "Opus 4.7 launch" and "Haiku 4.7 launch" are different.

Claude matches on the underlying subject, not the wording.

3. Material updates get tagged, not skipped.

If GPT-5 launched last week and this week the API opened up — that's a genuine follow-on, not a repeat. It appears with an UPDATE: prefix so I see at a glance what's fresh vs. continuing news.

4. Self-pruning.

Every morning, before writing today's entry, the task deletes anything older than 30 days from the page.

No separate cleanup task. No archive folder. The page maintains itself.

Here's roughly what the prompt looks like

A simplified version of the real thing:

You are my daily AI news briefing assistant.

STEP 1 — Check what I've already briefed
Fetch the Confluence page. Read the last 14 days of entries.
Build an already-seen list of subjects covered.

STEP 2 — Search the web
Find the top AI stories from the last 24 hours.
Focus on: model releases, product launches, research papers,
funding news, regulatory developments.

STEP 3 — Filter
Skip anything in the already-seen list.
Match on subject, not headline.
Genuine updates → include with "UPDATE:" prefix.

STEP 4 — Pick the top 5 stories
Rank by impact, not recency.
Fewer than 5 is fine — do not pad.

STEP 5 — Format bullets
• [Source] — [What happened]. [Why it matters]. (link)

STEP 6 — Update the page
Prepend today's section at the top.
Delete any section older than 30 days.
Keep everything else intact.

The real prompt has a few more details — a Monday-catch-up rule so weekend releases aren't missed, explicit source-priority guidance (official blogs first, aggregators last), and error handling so the task fails loudly rather than silently.

But the shape above is the whole idea.

What a morning actually looks like now

I open one Confluence page with coffee.

Today's section is at the top, dated, with a one-line summary ("5 fresh stories, 2 updates — busy release day").

Five bullets. Each one: who did what, why it matters, link to source.

Scan in ~90 seconds. Click into anything that's interesting. Done.

If I skip a day, nothing bad happens. The next morning's briefing catches me up naturally because the dedup window is 14 days, not 1.

No mental load to maintain. No "oh I forgot to check that site." No dread of inbox clutter.

Honest limitations

This isn't a silver bullet. A few real caveats:

Cowork runs locally. The scheduled task only fires when your machine is awake and the Claude Desktop app is open. If your laptop is closed at 9 AM, the task skips until you open it — and then runs late. For truly time-critical delivery you'd need cloud execution (Claude Code Routines), not Cowork.

It consumes usage quota faster than chat. Three daily runs isn't much, but if you stack more or run hourly, you'll notice.

Quality depends on the prompt. My first version pulled too much noise. The fourth version is what I shared above. Plan to iterate for a week.

Official connectors are intentionally read-only. That's a feature, not a bug — but it means you need to think about destination before you build.

What surprised me

I started this expecting to build a smart news aggregator.

What I actually built is closer to a personal intelligence briefing service.

The difference matters. An aggregator is passive — it pulls everything and lets you filter. A briefing service is active — it decides what you need to know, how to frame it, what to leave out.

And the pattern generalizes well beyond tech news:

Compliance: daily summary of new regulatory updates in your sector
Finance: weekly market-movement digest for your specific exposure
Sales: morning brief on pipeline changes and upcoming renewals
R&D: weekly competitor-release scan

Anything with the shape "check these sources, filter against what I already know, summarize the important bits" fits.

What I'd do differently

If you're building your own version, some honest advice:

Start with one briefing. Not three. You'll iterate faster on one, and you won't know if you'll actually read them until you do.
Run it manually for a few days before scheduling. Tune the prompt against real output.
Pick your destination deliberately. If you already have Confluence, Slack, Notion, or any tool with write access — start there. Don't add a vendor.
Don't over-engineer early. I almost built an archive system on day two. I would have regretted it if I'd stopped reading the briefings after a week.

The question that stuck with me

I set out asking: can Claude automate my morning reading?

After two weeks of this running, the better question is:

What else is quietly consuming 30 minutes of my day that could show up, pre-done, at 9 AM?

The briefings were just the start.

If you've built something similar — or if this sparked an idea — I'd love to hear it.

Rethinking Software Development in an AI-Assisted World

Nikul Pandya — Sun, 25 Jan 2026 08:13:24 +0000

I’ve been using AI-assisted development tools for more than a year now, across real production environments.

This isn’t an experiment.

It’s not a novelty phase.

And it’s not about letting AI “write the app.”

What has changed is where engineering effort is spent.

I still design systems.

I still make architectural decisions.

I still review, validate, and own the outcome.

But writing code is no longer the primary bottleneck in my workflow.

A Shift in the Unit of Work

Before AI, the unit of work in software development was often the line or the function.

With AI, the unit of work becomes the decision.

Instead of asking:

How do I write this code?

I now ask:

What should this component do, and what constraints must it respect?

AI is then used to execute those decisions efficiently, within boundaries I define.

Planning as a First-Class Step

AI is most valuable before any code is written.

When given requirements and access to existing patterns, it can:

Surface architectural conventions
Propose module boundaries
Highlight likely edge cases
Outline responsibilities across layers

This doesn’t replace design work.

It compresses the feedback loop between intent and structure.

Bad plans still produce bad code — just faster.

Implementation With Guardrails

During implementation, AI operates under explicit constraints:

Follow existing conventions
Respect architectural boundaries
Generate changes incrementally
Explain non-obvious decisions

The developer remains the control plane:

Approving direction
Injecting domain knowledge
Rejecting incorrect assumptions
Stopping over-engineering early

This model works because authority never leaves the human.

AI executes.

Developers decide.

Review Becomes More Strategic

AI-generated code still requires review — but the nature of review changes.

Instead of spending time on:

Naming
Formatting
Repetitive refactoring

Reviews increasingly focus on:

Correctness
Edge cases
Architectural fit
Unintended coupling

Static analysis and automated reviewers become more effective when paired with AI-assisted fixes, especially when review feedback is fed back into the generation loop.

AI doesn’t remove review.

It raises the baseline before review even begins.

Failure Modes and Limits

AI is not a reasoning engine.

Common failure modes include:

Confidently wrong assumptions
Shallow domain understanding
Subtle security oversights
Plausible but incorrect abstractions

This is why:

AI must never own final decisions
Tests remain non-negotiable
Security-sensitive code demands extra scrutiny

AI increases throughput.

It does not increase accountability.

What Actually Improves

After long-term use, the most noticeable improvements aren’t raw speed metrics.

They’re qualitative:

Reduced cognitive fatigue
Fewer trivial review comments
Cleaner diffs
More consistent structure across the codebase

Senior engineers spend more time on design and risk, and less time on mechanics.

The Emerging Role of the Developer

AI-assisted development doesn’t reduce the importance of engineers.

It clarifies it.

The developer becomes:

A system designer
A constraint setter
A reviewer of intent, not syntax
The final authority on correctness

Typing is no longer the scarce skill.

Judgment is.

Closing Thought

The future of software development is not AI writing code autonomously.

It’s humans and AI working in a tight, disciplined loop — where AI handles execution and humans handle responsibility.

If you adopt AI this way, the question stops being:

Will AI replace developers?

And becomes:

What should developers spend their attention on now that typing isn’t the bottleneck?

Vibe Coding: My Experience Building a Website with AI (Developer vs Non-Tech Perspective)

Nikul Pandya — Thu, 31 Jul 2025 09:46:37 +0000

🚀 Introduction

AI-powered coding platforms are transforming the way we build websites. Instead of writing every line of code, you can now describe your idea in plain language, and an AI agent generates a deployable project for you.

Recently, I experimented with one of these Vibe Coding platforms to build a static website for my startup. While the experience was exciting, it also revealed a clear gap between how developers and non-technical users interact with these tools and highlighted some current limitations.

💡 1️⃣ What is Vibe Coding?

Vibe coding allows you to create software simply by describing your vision in natural language. The AI agent handles:

Code generation
Deployment
Sometimes even UI design elements

The Promise

Non-technical founders: Build a site without hiring a developer
Developers: Save time on boilerplate tasks and focus on higher-level architecture

But does it truly deliver a no-code experience for everyone? Let's dive in.

⚡ 2️⃣ My Experiment: Building a Startup Website with AI

I started with a simple prompt to create a basic landing page for my startup. Within minutes, the platform delivered:

A functional website layout
A ready-to-deploy project structure

✅ First impression: Great for quickly spinning up an MVP.

🌍 3️⃣ The Multilingual Challenge

Later, I wanted my website to support English and Gujarati. I began by asking the AI to make this change using a general prompt.

Prompt 1 (General Request):

Please make the website available in two languages: English and Gujarati, ensuring that all pages and navigation elements are translated accordingly.

AI's Response:

The AI returned a highly technical solution, suggesting steps like:
Setting up i18n infrastructure with libraries like react-i18next
Creating translation files for each language
Implementing a language switcher component

For a non-technical person, this kind of response is difficult to act on. Terms like i18n and translation schema are not beginner-friendly and would likely require developer assistance.

👨‍💻 4️⃣ Developer Intervention
As a developer, I opened the generated files and saw that components could easily be duplicated for translations. So, I gave the AI a more specific, simplified instruction.

Prompt 2 (Developer-Guided Request)

The website content is relatively small. Instead of a full i18n setup, please create hardcoded translated versions of the pages (e.g., product_eng.tsx, product_guj.tsx) and add a simple language switcher in the header to toggle between English and Gujarati.

This time, the AI:

Created separate Gujarati page components
Added a functional language switch button
Delivered a clean and working solution ✅ without over-engineering the task

🔄 5️⃣ GitHub Integration: A Pleasant Surprise

After completing the website, I linked the project to my GitHub account, and this turned out to be one of the platform's most impressive features:

Any manual code edits I pushed to the main branch were automatically synced with the live deployment

The platform maintained full compatibility between the AI-managed environment and my manual changes

This gave me the best of both worlds:

AI-assisted rapid development

Full developer control when needed

⚠️ 6️⃣ Limitations of Vibe Coding (Current State)

While Vibe Coding is great for static websites and front-end-heavy projects, it still faces big challenges in more complex scenarios, such as:

Backend systems: AI struggles with database schema design, API security, and complex business logic
Data persistence: Managing relational databases, migrations, and scalable architectures isn't fully automated yet
Advanced integrations: Connecting third-party APIs, authentication, and cloud infrastructure often needs manual intervention

In my opinion, Vibe Coding is ideal today for small static sites or quick prototypes, but not for production-grade full-stack applications, at least not yet. This may change as AI coding tools mature, but developers remain essential for now.

📌 7️⃣ Key Observations (Developer vs Non-Tech)

✅ Developers

Can refine prompts and review generated code for better results
Benefit from GitHub sync to combine AI assistance with manual coding
Gain productivity but still need skills for backend, databases, and scalability

⚠️ Non-Technical Users

May receive responses too technical to act on
Might hit a dead end if the AI doesn’t get it right on the first try
Still need occasional developer support for anything beyond a simple site

🧠 8️⃣ My Takeaways on Vibe Coding

Huge potential for rapid prototyping and static site generation
Not yet ready for complex backend-driven applications
Best used in a hybrid workflow: AI for speed, developers for precision and scalability

🎯 Conclusion
Vibe coding is an exciting step forward in software development. It can dramatically speed up building small websites and prototypes. But when it comes to complex systems, backend logic, and database-heavy apps, traditional coding expertise is still essential.

Would you trust AI to build your next production app? Or do you see it more as a prototyping assistant?

💬 Share your thoughts below—I’d love to hear your experiences with AI-powered coding!