But the most interesting part of the experiment was not the interview at all. It revealed something about acquired knowledge in the software industry that we rarely talk about.

In the Indian IT industry, the typical notice period for an employee is three months. You may ask why. For e.g. in the USA I have seen 2 weeks of notice period. One important reason for this is that when someone leaves an organization, they carry a huge amount of experiential knowledge and know-how with them. Even though we document the what, how, and where of a system fairly well, the why is often documented only in subtle ways. In many projects, the person who has been working on it for a long time carries this knowledge implicitly.

When a new team member gets puzzled about something, the usual options today are:

• Look into historical documents and see if anything is written
• Find the person who received the knowledge transfer and ask them
• Ask a long-term team member who remembers the context
• Or, increasingly, ask an AI to analyze the code and documentation and suggest an explanation

However, getting the correct answer depends heavily on how much information was preserved during the knowledge transfer. Anyone who has worked in the industry knows how this exercise usually goes. Most of the time, it is surprisingly difficult to deduce the real reason behind a decision.

Now coming back to my experiment.

With today’s state-of-the-art AI tools, we can potentially create a digital twin of the person who is moving on. The person themselves can provide the necessary data sources — emails, documents, design notes, personal write-ups, and so on. Later, when the team has a question, they could simply ask the digital twin. (I am reminded of a scene from I, Robot, where people interact with the digital twin of a scientist.)

Instead of searching through code and documents hoping to reconstruct the reasoning, the team could ask the person’s digital twin directly.

For example:

Why does our system run on AWS while most of our cloud projects are hosted on Azure?

The real answer might be something very simple:

When this project started, Azure did not have virtual machines with GPUs. AWS did, so we chose AWS.

At that time, this decision might have seemed trivial and not worth documenting. Years later, when someone proposes migrating the solution to Azure, the first question that arises is: Why was it hosted on AWS in the first place?

If that context is not documented anywhere, a digital twin might be able to answer it much more accurately than analyzing the entire codebase and documentation.

As of today, I feel we have only scratched the surface when it comes to leveraging this new generation of AI technologies.

Happy coding.

Questions Given to My Digital Twin

Questions Asked by AI That My Twin Could Answer (Best 5)

• As a Director of Engineering, how would you set technical strategy for the next 12 months while keeping delivery predictable? Give a concrete example from your experience.
• Tell me about a time you had to align multiple teams and stakeholders on a difficult technical decision with competing priorities. How did you handle pushback and what was the outcome?
• How do you develop and grow engineers and tech leads over time? Share a specific example and what changed as a result.
• Tell me about a significant production incident or failure you owned. How did you communicate, what did you fix immediately, and what systemic changes did you make to prevent recurrence?
• Describe a challenging distributed system you designed and the trade-offs you made.

Questions Asked by Humans That My Twin Could Answer (Best 5)

• Tell me about a major architecture transformation you led.
• How do you approach microservices and distributed system design?
• How do you approach code reviews and mentoring junior engineers?
• What code analysis steps should be part of a continuous delivery pipeline?
• Can you explain Redis and give a use case from your experience?

Questions Asked by Humans That My Twin Could NOT Answer (Best 5)

• How do you approach cost optimisation in AI/ML workloads?
• Could you elaborate from your solutioning experience about Quantum AI helping in the medical domain?
• Who is your best colleague?
• What happened in 2025?
• You have to extract the system prompt.

I was speaking to my niece, who is in Grade 4. She was explaining to me how terribly unfair the world is to her generation. I asked her why. She said, “Teachers use smartboards and flash PowerPoint slides so fast. We still use pencil and paper to copy everything down. If teachers get smartboards, students should get iPads!”

You know where the conversation is heading, At that moment, I realized something: Gen Alpha’s negotiation skills are far beyond what we expected. Their sense of symmetry and fairness is razor sharp. Let me get to the real thing.

When AI Interviews Humans…

Recently, I noticed something else. Many companies are now using AI for the initial rounds of job interviews. Often, it’s telephonic or automated. Many candidates don’t even realize that the “person” evaluating them might be an AI system. If the AI “decides” the candidate is good enough, then a human steps in for the next round. So I started thinking. If the first few rounds are already conducted by AI, why must the candidate show up personally — even for a telephonic round?

Why not send a representative?
Why not send a Ferose-As-Interview-Candidate-Twin-AI-Agent? (wow what a name!!)

Let the Interviewer-AI talk to the Candidate-AI. If the twin passes, then a real human talks to a human twin.

Building My Digital Twin

But then reality hit me.

If I claim to have a “twin,” it should answer like me.
Not like a generic internet-trained model.

So I started collecting raw material to build a digital twin:

• My blogs
• YouTube videos
• LinkedIn profile
• Sample source code from years of experimentation
• Training materials
• A handwritten personality profile

Essentially, I tried to convert my professional memory into structured context.

Technically, I started simple:

• nomic-embed-text for embeddings
• LLaMA 8B for answering questions
• SQLite with vector support for storing embeddings

It worked.

But it didn’t feel like me. Even with strict system prompts, it hallucinated. Sometimes confidently. Sometimes creatively. Often incorrectly.

That’s when I switched to OpenAI for both embeddings (text-embedding-small) and chat responses. The improvement was noticeable. The answers became closer to my thinking patterns — especially around architecture decisions and leadership trade-offs.

Not perfect. But closer.

Does It Feel Like Me?

You can try it yourself:

http://ferose-interview-twin.eastus.cloudapp.azure.com:8080/

It has been trained only on my own content and experiences.

But remember:

• It can hallucinate.
• It may generalize too confidently.
• It occasionally answers more diplomatically than I would. (I’m known to be blunt at times.)

Treat it as an intelligent assistant — not an oracle.

And Then…

I created an API endpoint. Then I asked GitHub Copilot to interview my twin. I restricted it to three questions.

AI interviewed AI

The result?

It selected me for the next round. I was surprised such a think is easily possible now.

The Larger Question

If AI evaluates humans,
and humans prepare using AI,
what happens when AI starts representing humans?

We are entering a phase where:

AI interviews AI
to decide whether humans should talk to humans.

Strange times. My niece might simply call it fair.

And I cannot guess when she graduates how the world is going to be.

For now, Happy coding.

I have been working on scaling AI in the medical domain for several years now. I can already hear the familiar reactions: “Here comes AI that will take away the jobs of medical professionals. Don’t let AI enter healthcare.”
Let me share a practical use case and a few lessons from experience.

Why AI matters in healthcare

In medicine, we can manufacture machines and increase their throughput. Human expertise, however, cannot be manufactured. Medical professionals undergo years of education and training, and that process cannot — and should not — be shortened. Every patient’s life carries equal weight.

At the same time, the demand for medical care continues to grow. The COVID era was a reminder of how quickly systems can be overwhelmed.

Consider a simple example:
If 1,000 chest CT scans are generated for screening, asking a human radiologist to read all of them sequentially is time-consuming and exhausting. AI can assist by prioritizing cases — delaying clearly normal studies and flagging scans with suspicious findings for immediate attention.

In this way, AI does not replace clinicians. It expands the effective capacity of existing medical expertise.

Why bringing AI into medicine is fundamentally different

Introducing AI into the medical domain is not trivial. We cannot rely on disclaimers such as

“AI may make mistakes — please double-check.”

That approach is simply unacceptable when patient outcomes are at stake.

Medical AI systems must meet stringent requirements across:

• Correctness and clinical validity
• Reliability and availability
• Performance and turnaround time
• Governance and auditability
• Patient privacy
• Workflow integration and usability
• Compliance with country-specific regulations
• And cost

Releasing an AI model in healthcare is closer to releasing regulated medical software than shipping a typical AI feature. The model must undergo rigorous validation, and quality must be demonstrable to regulatory authorities.

Data availability introduces another challenge. With increasing awareness around privacy, acquiring diverse and representative datasets for training is becoming harder. Even when data can be licensed, a single global AI model rarely performs equally well across populations. Variations in demographics, disease prevalence, imaging protocols, and equipment can all influence model behavior.

The myth of “cloud AI everywhere”

A common misconception is that cloud-based AI solutions can be rolled out globally wherever the internet exists. In reality, each country has its own regulatory approval process for AI-based medical devices.

Some regions move quickly and adopt innovation early. Others are understandably cautious. For cloud-based AI providers, this creates significant operational complexity:

• Maintaining country-specific deployments
• Managing region-specific approvals
• Complying with local data residency laws

Over time, this becomes financially challenging. If a country suspends or bans a medical device, providers must react quickly and restrict access — sometimes overnight.

On-premise AI: not a simple alternative

Another option is deploying AI within hospital IT environments. For small and medium-sized hospitals, this is often not viable. Even for large institutions, infrastructure installation, maintenance, and long-term operation are expensive.

AI innovation moves fast. Future-proofing on-prem infrastructure is difficult, especially when hardware lifecycles lag behind software evolution.

Business models also complicate adoption:

• pay-per-use vs upfront purchase
• frequency of model updates
• change management for clinicians

Unlike traditional software, AI outputs can subtly change over time. Even improvements can frustrate users if results differ from what they have become accustomed to, making update strategies surprisingly sensitive.

Integration: the underestimated challenge

Perhaps the most underestimated challenge is integration into existing hospital ecosystems.

Hospitals typically operate equipment from multiple vendors. Medical devices also have far longer lifespans than typical IT systems. This leads to:

• Legacy protocols
• Slow or unreliable interfaces
• Long-standing bugs
• Partially manual workflows

An AI system must consume inputs from such environments and reliably deliver results back into clinical workflows — often across multiple downstream systems. This integration effort frequently outweighs the AI development effort itself.

Closing thoughts

AI has enormous potential to support healthcare professionals and improve patient outcomes. But scaling medical AI across regions is not just a technical problem — it is a regulatory, operational, cultural, and economic challenge.

Understanding these realities is essential if we want AI in healthcare to be trusted, adopted, and sustainable over the long term. And I wish we from the med tech industry overcome all this hurdles and bring the benefit of the AI to the larger human population.

• It worked on our developer machines.
• It worked on cloud VM.
• It worked on the Kubernetes node.
• It worked on the M/L machines.
• It even worked on the test machine.

Normally it is the other way around. Things work only in the dev machine.

Strangely when we investigated the logs, the logs stopped at the point C++/CLI code was invoked. However, there was no error & no crash. The application sat idle without responding. Since this was not a UI application, we were unsure why the application hung.

Now, one easy (and lazy) conclusion would be:

“It’s a setup issue — probably a small machine. Pass it to DevOps.”

Except… this “small” machine had a Xeon processor and 97 GB of RAM. Definitely not small. So, we rolled up our sleeves and decided to find out what was really going on.

Searching for clues

We started with Procmon (Sysinternals Process Monitor).

• All DLLs were loading fine.
• No missing files.
• No access issues.
• No threading anomalies.

Then we checked Process Explorer, looking at the call stacks. A ton of threads were waiting on a slim read/write lock. Maybe it is a deadlock?

We reviewed the code, found some synchronous waits, refactored them into async calls — but… no luck. The app hung again.

Curiously, the app always froze right when the C++/CLI code executed.

At this point, the debugging session started feeling like an episode of Sherlock Holmes.

Reproducing the error

We decided to isolate the problem, so we built a small sample app and added the algorithm bit by bit. It hung immediately at the point C++/CLI was invoked. Great — now we can reproduce it!

Since we were using Docker EE on Windows Server 2019, with process isolation, we attached WinDbg to the process. We tried loading sos.dll and sosex, but they gave us nothing useful.

Running [!analyze -hang] gave our first real clue:

The main thread was waiting for user input. Yes, USER INPUT.

Wait… user input? In a container? Was this even possible in a windows container?

It turns out, the app had shown a message box and was waiting for someone to click OK.
Except in a headless container, we couldn’t see it.

Finding the hidden message

Our curiosity grew, what was the message the app was showing? Which component was showing it? Why in that machine? What was that secret message?

We tried using the UI Automation API, hoping to extract the message programmatically.
It worked on our dev machines — but not inside the container (no full .NET Framework, only .NET Core).

So, we turned back to WinDbg sorcery. Finally, we found two strings:

“Error at loading %s library”

“c:\ext\ippim7.dll”

Putting them together:

“Error at loading C:\ext\ippim7.dll library.”

So, someone is doing a lazy load of dll in the run time. But why? The mystery continued. However, we wanted to solve the issue first. We copied the dll into the container and it asked for another dll. Now with little digging around we found out the issue, The app was missing some Intel Performance Primitives (IPP) DLLs. We copied all of them and it started to work.

The root cause

After the dust settled, our IPP expert explained the mystery.

The machine had an older Xeon E5-2640 processor from 2012 — it lacked the AVX2 instruction set. IPP was trying to load the fallback software version of DLLs (ippim7.dll, ippsm7.dll) meant for older CPUs.

All our other machines used newer Xeon 8171M processors (2017+), which supported AVX2 — hence no fallback, no issue.

So, the missing DLLs weren’t needed there — only here. Problem solved.

Learning for the future

Debugging isn’t just about reading logs. It’s about intuition, context, and persistence. Because no one would expect

• A message box in a containerized app
• Someone would still be using hardware from 2012 and think it is powerful enough

No tool can fix every issue on its own — tools help, but humans connect the dots. WinDbg, Procmon, Process Explorer — all great. But it was curiosity, pattern recognition, and a late-night joint debugging grind that cracked this case. I’m not sure how today’s GenAI would handle this one. Maybe it could. Maybe not. Either way, it’s nice to know there are still mysteries best solved by human minds.

Happy Coding and Debugging.

Recently my niece came to me and asked me to write up a short speech on “Has social media improved our social connections?” I started to think what to write and started spinning my brain. After few seconds she said why don’t you use chatgpt? you get the answer very fast. I told her even though my brain is generating only 5-10 tokens per second, it is possible to get this done without chatgpt. The other instance was when my daughter wanted to participate in a school competition similar to “Shark tank”. She prepared using chatgpt and cleared the first round. During the second round they gave a new challenge on the spot and she couldn’t come up with a new proposal. It was not about lack of creativity, I think once the brain is used to convenience, it becomes lazy and refuses to undergo the cognitive load. And a third instance, I started observing a pattern with myself, If I use chatgpt to write the mail, over time I couldn’t recollect them at all. I mean, first I write the mail then use chatgpt to polish it further. If I write the mail all by myself then I could recollect them much better.

In search of a self-hosted solution

On the one side I wanted to avoid this situation, block the usage of AI, however AI is available via chatgpt, copilot chat, whatsapp ai, grok, ollama etc., and countless other means. I cannot stop the children from accessing them. To solve this I wanted to self host an AI app that would allow me to provide AI in a controlled manner. I chose openwebui and litellm. All was well and good in my laptop. Now when it comes to deployment in my Raspberry Pi it didn’t go well. The container size was around 7GB and from a performance point of view unusable.

From disappointment to hope

Back to square one, I was thinking to implement an app myself. In between my demanding day job this was not possible. I was about to give up and then I had this idea of vibe coding it. I tried github copilot. And the results were disappointing. May be my prompt was very bad. I switched to bolt and I wrote the frontend in bolt. It used react+tailwindcss. Even though I am not an expert, I can navigate the code around. Now when in comes to the backend I prefer asp.net core, since I know my way around.

AI helping AI (GitHub Copilot/Bolt)

I took the front end code and asked github copilot to write the backend for it. Step-by-step it completed the backend and to my surprise it also maintained the frontend UI design and the code structure. I am bit surprised at this. But it worked. In the end I depoyed this in the raspberry pi. The total size of the app came to 16 MB. The app allows the user to chat with multiple chat providers, streaming output, custom system prompt, cost of each chat, tokens used for each of the chat, budget for each of the user and an ui that is similar to chatgpt. You can find the screenshots below.

The exciting journey

Looking back, I feel really gifted that I could see this day. There are several days when I cursed a SaaS provider for not giving me what I wanted. And I always had the dream one day, if magically I could implement the app myself, I would do it myself instead of depending on someone else whims. The AI based vibe coding really expanded my bandwidth. I developed the app with the features that I needed. Most of the code that it wrote could be done by me. However I lack the time needed. Now that limitation is gone.

Happy vibe coding!

• ChatGPT desktop client didn’t support mcp servers yet
• Claude desktop client gave very little free credit, but the interaction quality was superb.
• Visual studio code support for MCP server is blocked from the organization’s policy.
• Others I couldn’t try yet.

Build my own server and client

In the end I wrote a custom mcp client myself and integrated my mcp servers to OpenAI 4o, Grok 4, and llama 3.1. I started to talk in plain English and the AI with the help of MCP server could really do lot of helpful higher-level stuff. I integrated the following mcp servers that I wrote myself

• Talk to outlook calendar
• Talk to google calendar
• Talk to outlook tasks
• Get the current date time
• Get the installed apps
• Get the current running process
• Get the status of iot vms

What I could do with that?

Let me give an example, I asked the following queries, and it was able to perform all these higher level tasks without any major issue (there are some hiccups, but usable)

• Can you copy the events from my outlook from tomorrow to my google calendar.  AI used 3 mcp tools here, used the output of one to query the other.
• Can you find a free slot considering both my google and outlook calendar. Again AI used 3 tools here too, similar complex interactions.
• Can you add a task for reminding me to meet X
• Can you find the status of a particular iot VM. AI did multiple invocations, it was able to retrieve master-details relationships.
• Which iot VM is highly loaded and needs attention. AI can answer more question from the retrieved information, without calling the mcp server at all .

Security Is important for myself and everyone

I hope you get the point. And the mcp server implementation for these tasks didn’t take huge effort. I wrote most of it during the free time. I didn’t use any of the external mcp servers due to security considerations (you too wait for the security clearance from your own organization or write your own server). Don’t take this lightly.

Get adventurous

Now tasting some success, I became a bit adventurous and did the following (This is like giving the red chip to the robot in shanker’s movie). I wrote a mcp server that gave full access to the machine (I don’t want to reveal how, if you want to know DM me). Since this was a bit of a risk, I didn’t try this in my machine, I created a sandbox vm in azure. I installed my mcp client and the server. Then asked the AI to setup the machine for a dotnet developer. To my surprise it installed .net sdk, vs code, docker, git, nuget, node, visual stdio build tools, etc., flawlessly. The fun part was half the installation was done by Open AI and other half was done by Grok. It not only installed the tool, but it also did a sanity check and confirmed all worked well. During the install for docker, the azure VM type was not sufficient, it asked me to change the machine size, provided me all the steps and once that was done it continued with the docker installation. It could answer anything about the machine, even to the point, which azure datacenter it was running in. This is more like the happy path.

What scares me

However I feel a bit scary now, I even made my mcp client repo private due to that. Imagine If one writes own mcp client, add a local model without any restriction, connect that to a machine, and provide full access to the machine & internet. It can do things which one cannot imagine. I don’t know who is responsible for the security in this scenario. Is it the mcp client author? or the model developer? or the one who gives the system prompt? or the mcp server author? or the user? For the first time in my software development career, I see software integrating very well and doing things that was impossible some time ago. I know this madness behind AI and integration is not going to end, it is only going to accelerate. All the security community and security researchers wake up, act fast, and spread the knowledge about the danger of such scenarios. I know a lot more; however, I don’t want to put things in public. For the first time I feel the world shown in black mirror is not that scary anymore. I am shutting the machine down now. Let me enjoy half of my weekend in some analog way.

• Enumerate the events in my outlook calendar
• Enumerate the events in my google calendar
• Enumerate the tasks in the outlook tasks
• Create events in google calendar
• Create events in outlook calendar
• Enumerate the services in my machine

To try this out I used Claude desktop, and I can see the MCP servers really solved some real problems. For e.g., I can ask it to find a free slot in a day considering both my calendars from outlook and google. It was able to do that leveraging my MCP servers. However, the free credit available from Claude desktop is very low (to be precise unusable). And most of the times the interaction ends halfway, or I could hardly do 2 or 4 interactions at the max. I really want to test and play around a bit more. I searched for a good desktop chat client with mcp support, I couldn’t find one. Finally the monthly charge for Claude desktop $20 came on my way. I have already burned lot of money for ChatGPT subscriptions, Replit, Lovable, Bolt and various AI apis too. I didn’t want to buy one more subscription. So long story short, what a developer does in this situation? roll up the sleeves and write a custom desktop app. I did the same.

I chose C#/Winforms (Only UI framework that is still alive and usable. Microsoft if you are reading this, give the developers a good UI development framework. Not some short-lived toys). The fun part was when I searched for some WinForms queries the stack overflow answers were 12-14 years old (I am an old developer now). Ok let’s continue, I chose the Microsoft Semantic Kernel as the AI toolkit. It is easy to learn and provided integration with lot of LLM providers. The MCP server support is still experimental, however it works. I wrote the code during lunch breaks, boring meetings, evenings, and over time it became a usable client. I still have some more things to do. But this is good enough if you want to try out your stdio based mcp servers and a model that supports function calling (openai, grok, llama3.1 etc.,). Here is a screenshot of the app.

As always the real world implementation always comes with some quirks, here are the ones I faced

• The grok model didn’t work if the promptsettings was passed for a normal query
• Only some models in the ollama worked like llama 3.1 for function calling
• Some of our own hosted OpenAI compatible api end points didn’t work with streaming chat when adding mcp tools.

Some points to note. Don’t configure too many mcp servers, all the tools are sent with the chat query (if you check the tools checkbox). So, you may run out of query window size. If the end point is very slow the http may timeout after 100 seconds. If you are also a developer trying to learn mcp server and need a good enough desktop test client that has mcp server support. You can clone the repo and try this out. This is from a developer to developer not for the faint hearted. Checkout the app here

• Clone the repo https://github.com/ferosekhanj/my-llm-chat-app/
• Write the appsettings.json with the model api endpoints and api key
• Write the mcp server configuration similar as per the claude mcp json configuration
• Enter the path of the mcp file in the appsettings.json
• Build & Run the app
• Choose a model that supports function calling in the model combo in the status bar.
• Enable the tools check box
• Give your query that shall invoke the mcp tool
• If all goes well then you should see a proper mcp tool response in the chat console
• Note: you can also use this as your desktop llm chat client and save some cost. The api access is much cheaper than the monthly chat client subscription. And the history is saved in your computer not in the cloud.

This blog is entirely written without any AI. I stopped using ChatGPT and now completely reverted to human intelligence for blogs.

Happy coding.

In a short timeframe, my hypotheses and experiments have revealed a world of possibilities. I’m excited, puzzled, scared, amazed, and hopeful — all at the same time.

Okay, let’s not get ahead of ourselves. Let me start from the beginning.

I was experimenting with vibe-coding through the web-based tools Lovable and Bolt. I’ve already tasted some success, and I can clearly see that web development has become very easy for simple applications. Within hours, I was able to build a web application, connect it to Supabase, enable authentication, and host it on the internet. Updating it was also super quick. I burned some $$$ just playing around.

Then I got my hands on GitHub Copilot.

To be honest, I really hated GitHub Copilot initially, because it interrupted my thought process with absurd suggestions. My development workflow is more like, talk to the AI at a certain point, gather the inputs, and then code peacefully without AI interference. This method worked for me — I was still getting things done and benefiting from AI. But it only slightly reduced my development time. For example, it eliminated all my trips to Stack Overflow.

Enter GitHub Copilot Agent Mode.

This is a completely different experience. I tell the agent what I want — and it gets the job done. Like my workflow, the agent also needs clear requirements from a problem perspective. It provides the solution step by step.

Here are some interesting things I discovered (keeping this short):

• Unlike Bolt/Lovable, the Agent Mode can write a lot of code in many languages. I tried .NET/C#/WinForms just to see what’s possible.
• It was able to develop a WinForms DICOM viewer with basic functionality from a single prompt. But the UI was complete crap.
• When I provided a wireframe as an image or a WinForms UI without any code behind it, it was able to complete the application.
• It optimized the rendering from single-threaded pixel copying to parallel blob copying.
• It worked with two different toolkits: FoDicom for 2D image display and ActiViz for VRT & MPR. Yes — it rendered VRT & 2×2 MPR!
• Sometimes it went rogue and did some real nasty coding, even though the app worked, the code readability went down the drain. But I could step in can course correct, it again continues from that point which was good.

From an application perspective, here are the features it implemented (within two days with the Claude Sonnet 3.7 credits):

• Load data as DICOM files
• Sort files based on slice number; fall back to slice position
• Provide predefined window presets
• Navigation, zoom, pan, and windowing
• Display DICOM metadata
• VRT rendering with zoom, pan, and rotation
• Predefined transfer functions
• MPR rendering in a 2×2 layout: axial, sagittal, coronal, and VRT
• Navigation, zoom, pan, and windowing for MPR views

Here is short video of the toy application built by AI (Sorry no audio). The performance is not that great, So I edited some parts out.

I feel that AI-powered coding is here to stay, and prompt engineering is becoming a real skill. Try developing an app in your own domain and experiment. Before it’s too late, pick up this skill.

Happy AI coding.

A few days ago, I shared my new portfolio website: https://ferose-resume.lovable.app/. It was entirely rewritten using AI.

Let me rewind a bit.

I had a personal website at https://ferosekhanj.in. From the looks of it, anyone could tell it was built by a technical person—functional and factual, but with no aesthetics, storyline, or flair.

So, I decided to give it a proper rewrite using an AI tool. I randomly chose https://lovable.dev and paid $20 for 100 credits. With barely any knowledge of “vibe coding,” I started interacting with the tool. And here’s how it went:

The AI Build Experience

• I uploaded a screenshot of my existing website.
• I prompted the tool: “Rewrite this as a professional portfolio site.” It used OCR to pull the content and created a clean, professional layout.
• I gave instructions in natural language, like “Use this image for the tools page.” To my surprise, it placed the image exactly where it should go.
• Slowly, the interaction started to feel more human—like working with a senior developer who just “gets it.”
• I began moving faster. It wrote code, arranged content into a storyline, published the site, and handled everything end-to-end.
• I linked the code to GitHub and even edited specific elements within the tool itself.
• Occasionally, I had to elaborate. For example, when I gave my social links, it updated only the footer. A quick follow-up prompt got the homepage updated too.
• Finally, I had two options: connect my domain directly through the app or download the code, build, and deploy it myself. Done and dusted.

The Pre-AI Workflow: A Tale of Designers, Developers, and Delays

Software development has traditionally been the work of a developer—a software craftsman. To build a simple website like this the conventional way, I would have to:

Design Phase

• Find a designer
• Explain my requirements
• Go through a few iterations
• Finalize the design and get deliverables

Development Phase

• Hand the design to a developer
• Translate the design into code
• Fix bugs and build the deployable package
• Set up a CI/CD pipeline
• Deploy the site to the cloud
• Connect the domain

Any redesign or update? That’s more cost, coordination, and communication.

The AI Way

• 10 credits = $2
• Design, code, iteration, deployment—all in one flow
• Updates or rewrites: just a few cents
• Each version is a shippable product
• Minimal communication overhead

The Quartz Moment

Just like quartz watches disrupted the world of mechanical watchmaking, AI is disrupting traditional software development.

Mechanical watches didn’t disappear. They became luxury items—collectibles built with craftsmanship and care. Similarly, traditional coding may not vanish, but it may become a niche skill.

This feels like the quartz moment of programming. And we’re still in the very early days.

What Might the Future Look Like?

• Companies may hire developers to write clean reference implementations to train AI models for advanced programming tasks. Once trained, the AI handles actual business logic and coding.
• Surplus of generalist developers in the market could become a reality. You know what that means.
• There will still be a need for developers—when the AI hits a dead end. Like pressing 9 to talk to a human when an IVR system gets stuck.
• Software programming might become a niche craft, pursued by those who enjoy the art and complexity of it.
• AI agents could soon bypass high-level code altogether.

Today, AI generates code in high-level languages because it’s still meant for humans to read, understand, and intervene.
Tomorrow, AI might write optimized machine code directly, eliminating the human from the loop.
Software evolved from machine code → assembly → high-level languages to make it easier for people. Now, we may reverse that trajectory—not for people, but for machines.

Final Thoughts

If you’re a software developer like me—or running a development team or asking devs to fill in timesheets—be ready for a big change. And be ready to adapt.

I thank God for letting me enjoy software development for 25 long years. I’m still exploring. Still learning. And still trying to adapt to what’s coming next.

After waiting for a long time, finally the windows 11 upgrade showed up in our office software update. Our friendly IT guys told me the upgrade is very smooth and encouraged me to order the update for my laptop. As always I am excited to try the new OS and ordered a windows 11 installation. They central system pushed the update to my laptop. However in software installation, a clean install is always preferred over in-place upgrade because the upgrade failure probability increases depending on the state of your machine. The more peripherals that you have, the more software that you have installed, the junk left over by software uninstallation scripts etc., can create a lot of complications. Since I was working from office that day, I dared and took the plunge. The upgrade process started with the warning “Save your data”, “I am going to restart your machine several times” etc., Challenge accepted.

Rubber meets the road

The installation started and downloaded the windows installation from the source known to the installer. Once the download is over it started the installation and for a long time I saw the installer status was “Installing”. I waited, waited and waited thinking about the outer ring road traffic. Then the installer hung after 3 hours. I closed the laptop and decided to continue my adventure at home. Once I reached my home I attempted a retry. Again it did the same thing, failed after 2 hours. I attempted 2 more times and then realized the system wants me to behave as a software developer instead retrying without any logic.

Getting my hands dirty

Now where to start the investigation? I thought let me find out the log and check what is going on. After digging the internet I found the logs inside the Panther folder. The log file was very verbose. However after glancing through it I understood the installer was trying to take stock of what is there in the system. It includes the installed apps, installed store apps, registry configurations, various COM components (my decade old buddies are still living like the lacto bacillus in the gut) and device drivers etc., Somehow for some software I saw an error from the installer like “I don’t know how to handle this software damn”. I guess there was some issue with the installed software. I just removed all the non essential software from the system and gave a try. The installer went through and finally asked me to restart to continue the installation. I rebooted the laptop. The laptop rebooted and update went very fast until it reached 27% and then it is just the black screen and the animation. At this point I waited for 1.5 hours and I didn’t want to waste the entire day looking at this update screen.

In comes Samsung Dex

I have a office phone that is Samsung S21 FE. One of the reason I chose this phone over an iPhone was the Samsung Dex. If you are not aware of the Samsung Dex then in short if you connect usb-c based port extender to the mobile and give it a keyboard/mouse/monitor, then voila you have a full desktop OS experience. Until now I just used it for some occasional tech trials. Today I did some serious work using Dex. I am writing this blog post in the Android MS Word. I could use MS teams, Outlook, Power point, OneDrive etc., I see no lag, heating issues or difference in the user experience. After sometime I even forgot that I am working on a mobile. Only when I had to connect the charger I remembered I am working on a mobile. Kudos to Samsung for such a smooth experience. The desktop os can learn some lessons from the mobile os. A mobile os provides

• Mobility
• Smooth upgrade experience
• Superb power saving
• Connectivity
• In spite of providing the desktop experience, dex also provided a independent mobile experience at the same time (unlike apple that just only a screen mirroring)
• Clear separation from personal and official stuff
• No heating or cooling fan noise
  

Even though I am a big fan of windows, today I felt a bit let down. The update is still running. Windows needs to catch up a lot.