DEV Community: Vishwajeet Singh

One Portfolio, Infinite Versions: The Power of Agentic Personalization

Vishwajeet Singh — Sun, 01 Feb 2026 11:06:06 +0000

This is a submission for the New Year, New You Portfolio Challenge Presented by Google AI

About Me

My work is driven by a simple belief: the most memorable experiences are the ones that feel personal. I’m Vishwajeet Singh Thakur, an entrepreneur and software engineer who views technology not just as a tool for scale, but as a canvas for meaning.

In a world where digital interactions often feel generic and impersonal, I believe we’re standing at a turning point. Modern technology is powerful enough to recreate the nuance, warmth, and relevance of human connection - if used intentionally. That conviction led me to trade a stable career in 2025 for a singular mission: embedding personalization into the DNA of digital experiences.

This philosophy shapes everything I build, from my venture Invysia to the portfolio you’re exploring here. Each project reflects a focus on precision, empathy, and thoughtful design - demonstrating that deeply personal, engaging digital experiences are no longer slow, expensive, or experimental. With the right technology and mindset, they can be built with a speed and quality that was previously unimaginable.

This portfolio is not just a showcase of my skills but is a statement of intent.

Portfolio

This portfolio is not a static website; it’s a living, adaptive experience. What you see here is a curated expression of the same body of work, reshaped dynamically based on who you are and how you choose to engage with it. Visitors can select from four distinct personas and sixteen languages, resulting in sixty-four unique variations of the portfolio, each tailored to a different context, mindset, and intent.

Behind the scenes, the site is powered by an agentic backend that generates content on demand at the moment of interaction. Using a lightweight, high-performance generative model (Gemini 2.5 Flash), the system balances speed and cost efficiency while delivering coherent, relevant narratives in real time—ensuring that no two visits feel exactly the same.

The intelligence goes deeper than presentation. Its multi-agent architecture syncs with my personal GitHub repository through an MCP server, automatically discovering, summarizing, and contextualizing projects as they evolve. This means the portfolio stays current by design, reflecting real work as it changes, rather than snapshots frozen in time.

The interface is also attentive to user behavior. It adapts to how you navigate - anticipating intent, reducing friction, and offering shortcuts when needed. If you skim quickly, it proposes a concise overview. If your question isn’t answered through predefined paths, you can engage directly with the agents through conversation.

All of this is wrapped in a deliberately minimal, clutter-free interface. The goal is restraint, not absence, removing visual noise to make space for meaningful interaction. The result is a portfolio that doesn’t just show what I’ve built, but actively demonstrates how I think about technology, experience, and personalization.

Explore the live portfolio experience:
https://portfolio-frontend-268314723675.us-central1.run.app/

How I Built It

This project is a reflection of how my development workflow has evolved alongside modern AI tooling. Before 2026, my setup revolved around a familiar combination of IntelliJ IDEA or VS Code paired with Cline and Claude Opus. Over time, however, I found myself optimizing not just for code quality, but for momentum—and that led me to rethink the role of the IDE itself.

In late 2025, I transitioned fully to Antigravity IDE, which has since replaced both IntelliJ and VS Code as my primary environment. It allows me to work closer to intent than syntax, reducing friction between thought and execution. For implementation-heavy tasks, I rely on Claude Opus 4.5 for its consistency and depth in reasoning. For exploratory and research-oriented work, Gemini Pro has become my model of choice. I also use the Gemini CLI directly within the terminal, enabling fast, contextual search without breaking focus or switching contexts.

From a technical standpoint, the stack behind this portfolio is intentionally lean. The front end is built with Next.js and TypeScript, providing a performant, type-safe foundation for dynamic UI. The agentic backend is implemented in Python using Google’s Agent Development Kit (ADK), which orchestrates content generation, behavioral adaptation, and real-time data integration.

The result is a system where tooling, models, and architecture work in concert - each chosen not for novelty, but for how effectively they support rapid, high-quality iteration.

For those curious about how it works, the code lives here:
https://github.com/vishwajeet22/portfolio

What I'm Most Proud Of

What stands out most to me is not any single feature, but the compression of effort into outcome. Using this toolchain, I was able to design and build something that is meaningful, interactive, and expressive of my values, vision, and mission - end to end - in just two days.

Not long ago, a project of this scope would have taken weeks of fragmented work. This build is proof of how far the craft has advanced: when the right tools are paired with a clear intent, speed no longer comes at the expense of depth or quality.

Orchestrating Creativity with Agentic AI: How I Built a Real Business Using Autonomous Agents

Vishwajeet Singh — Sun, 14 Dec 2025 16:02:19 +0000

This is a submission for the Google AI Agents Writing Challenge: Learning Reflections

Building a Real Business with Agentic AI

Advancements in Artificial Intelligence have quietly - and sometimes dramatically - redrawn the boundaries of human creativity 🎨. Domains once constrained by time, effort, and human bandwidth, such as - digital art, music, poetry, and design - have expanded at an unprecedented pace. What felt impossible yesterday is now not only achievable, but repeatable.

As the founder of a company focused on customised and deeply personalised digital gifts, I found myself standing at the intersection of creativity and automation. Our belief was simple, yet ambitious:

If AI can generate intelligence at scale, why can’t it make every customer feel individually understood at scale?

What followed was not just a technical experiment, but a formative learning experience - one that reshaped how I think about systems, scale, reliability, and human trust.

🌱 The Experiment That Sparked Everything

At Invysia, personalisation is not a feature layered on top of a product—it is the product. Every calendar, every digital artwork, every personalised website is created uniquely for the customer. No templates reused. No shortcuts taken.

Inspired by the rapid advances in AI-driven creativity, we launched a pilot project: invysia.store. The vision was bold:

Use AI to create and deliver highly personalised digital products end-to-end, with minimal human intervention.

On the surface, it worked:

Calendars were generated from scratch
Designs were tailored to individual stories
Customers loved the uniqueness

But operationally, cracks began to appear.

Behind the scenes, we were still:

Spending hours conversing with customers to understand intent
Manually refining prompts
Relaying feedback between AI outputs and user expectations
Acting as an invisible orchestration layer

The uncomfortable truth became clear:

AI had accelerated creation - but humans were still coordinating everything.

This was not scalable. And more importantly, it was fragile.

🧠 The Realisation: Creativity Scales, Coordination Does Not

Despite my background in computer science, agentic AI initially felt abstract and intimidating. There were too many choices - models, frameworks, orchestration styles - each promising autonomy, yet offering little clarity on control, reliability, and cost.

The idea of running a business end-to-end using autonomous AI agents raised hard questions:

How do you trust non-deterministic systems?
How do you debug decisions made by probabilistic models?
How do you prevent runaway costs?
How do you ensure continuity when an agent fails?

These questions stalled progress - until I discovered the Google 5-Day AI Agents Intensive on Kaggle.

🎯 The Turning Point: Learning to Engineer Agents, Not Just Prompt Them

This course did not glorify agents as magical entities. Instead, it treated them as production systems.

Over five days, agentic AI was broken down into engineering primitives:

Models
Tools
Orchestration
Context & Memory
Evaluation
Deployment

What surprised me most was that nearly 75% of the course focused on what traditional software engineers already care deeply about:

Observability (logs, traces, metrics)
Reliability and evaluation
Cost optimisation
Security and governance
Production readiness

That was the missing piece. Agentic AI was not abandoning software engineering - it was extending it.

🤖 Applying the Learnings: Building a Real Multi-Agent Business System

Armed with this clarity, I rebuilt the core of Invysia as a multi-agent system, not a single all-knowing chatbot.

Two agents. Clear boundaries. One coherent system.

🟣 Iris — Sales & Support Agent

Iris is the first point of contact. She:

Handles customer inquiries and FAQs
Explains pricing and timelines
Conducts requirement discovery through structured questions

Crucially, Iris does not pass raw chat logs downstream.

Instead, she performs context engineering.

From unstructured conversations, Iris extracts structured intent - a clean, validated JSON object containing:

Theme preferences
Color palettes
Aspect ratio and resolution
Delivery timelines

This structured context is stored in ADK Session State, allowing it to persist reliably across agent boundaries. The outcome is not “shared memory” in the abstract - it is shared understanding.

🟠 Daedalus — Designer Agent

Daedalus never talks to the customer. He receives only structured intent from Iris.

His responsibilities include:

Generating creative prompts using a dedicated prompt-generator sub-agent
Producing 12 monthly calendar designs asynchronously
Handling payment link generation and delivery

Importantly, Daedalus is not a free-form creative chatbot.

He is strictly bound by tools:

A specific Image Generation Tool
A Template System that enforces layout, typography, and aspect ratio

This ensures Daedalus behaves like a software operator, not a hallucinating artist. He cannot invent formats, bypass templates, or deviate from constraints, but still creates engaging artworks.

🧩 Learning 1: Designing Boundaries Matters More Than Designing Intelligence

One of the most important lessons I learned is that agent reliability comes from boundaries, not brilliance.

Early on, I tried to make agents smarter—better prompts, deeper reasoning, larger models. Most failures, however, came from unclear responsibility, not lack of intelligence.

So I flipped the question:

“What is this agent not allowed to do?”

Iris never designs
Daedalus never sells
Each agent has permissioned tools and scoped authority

This reduced hallucinations, simplified debugging, and made behavior predictable.

🧠 Key insight: I stopped trying to make agents smarter and started making them more disciplined.

⚡ Learning 2: Speed Comes from Parallelism, Not Better Models

Another breakthrough was realising that latency is an architectural problem.

Initially, workflows were linear:

Prompt creation blocked image generation
Each step waited on the previous one

By redesigning the system:

Prompt generation runs in parallel
Image creation happens asynchronously
Agent handoffs are non-blocking

The result was dramatic.

What once took 3–5 days now completes in under 5 minutes - without upgrading models or increasing cost.

⚡ Key insight: The biggest performance gains came from letting agents work in parallel - just like effective human teams.

🛠️ Learning 3: Cost Optimisation Is a Design Choice, Not a Post-Processing Step

The course emphasised that model selection is architecture, not configuration.

I applied this directly:

Gemini 2.5 Flash powers Iris - fast, lightweight, cost-efficient for frequent conversations
Gemini 3 Pro Image powers Daedalus - used only after conversion, where high-quality output matters

Heavy compute is triggered only when value is guaranteed.

💰 Key insight: Every agent decision has an economic footprint.

🧍 Learning 4: Human Fallback Is a Reliability Feature, Not a Weakness

Autonomy without trust slows adoption.

The system was designed with human fallback mechanisms:

If Iris fails, a human can step in without breaking the flow
If Daedalus fails, a human designer can take over using the same structured context

The pipeline never collapses-it degrades gracefully.

This mirrors enterprise reliability patterns and builds confidence for both internal teams and customers.

🤝 Key insight: Human-in-the-loop is not a crutch; it is a trust accelerator.

🌍 How These Learnings Benefit Everyone Involved

Customers

Near-instant delivery
Consistent quality
Truly personalised designs

Team

Reduced operational fatigue
Clear intervention points
Focus on creativity, not coordination

Builders & Founders

Proof that agentic AI is not hype - it is engineering
A blueprint for scaling creativity responsibly
Confidence that small teams can build production-grade systems

✨ Closing Reflection

This journey taught me that the real power of agentic AI is not automation - it is alignment.

Alignment between:

Intent and execution
Creativity and control
Human values and machine efficiency