What if existing software could reshape itself based on natural-language instructions?

Around 8–10 years ago, when I was learning to program, I had this idea inspired by shapeshifters in science fiction.

What if software could change its own UI, workflows, and behavior depending on what a user needs?

Not just through configuration options, but through natural-language instructions.

Imagine telling an existing CRM:

>Reorganize the dashboard for our sales team so customers awaiting follow-up appear first. Also, create a reminder workflow for customers who haven't responded in three days.

Instead of requiring a developer to implement these changes, the application would use its existing capabilities to make the changes, validate them, and provide a way to roll back if something goes wrong.

I've been calling this idea Shapeshifting Software.

The interesting part isn't simply adding an AI chatbot to an application. I'm thinking about an architecture where AI is built into the application from the beginning, with a controlled set of tools and capabilities it can use to modify the system.

Conceptually, this is similar to how coding agents like Claude Code and OpenAI Codex interact with codebases through tools, instructions, permissions, and execution workflows.

The application would define what the AI can change, what must remain protected, how modifications are tested, and when human approval is required.

A few days ago, I started exploring this idea through an architectural proposal, an AI agent skill file, and a small demo.

GitHub: https://github.com/TriptoAfsin/shape-shifter

This is an early-stage experiment, not a production-ready implementation. I'm interested in understanding whether the underlying architectural approach makes sense.

Some questions I'm trying to work through:

• Configuration vs. code: Should an adaptive application modify declarative configuration, generate or modify source code, or combine both approaches?
• Security: How do we prevent an AI from accidentally weakening permissions, bypassing business rules, or exposing sensitive data?
• Reliability: How can changes be validated and rolled back reliably, especially when database schemas and interconnected workflows are involved?
• Architecture: Would a built-in AI harness with explicitly defined capabilities be a good foundation, or is there a better pattern for this?
• Consistency: How do we make sure similar instructions produce predictable outcomes without making the system too restrictive?

I'm particularly interested in perspectives from people working on software architecture, developer tools, AI agents, and enterprise applications.

Does this seem like a practical direction for AI-native software, or am I overlooking an architectural pattern that already solves most of this?

I'd appreciate critical feedback, alternative approaches, relevant research, and suggestions for improving the experiment.

Meet Porter, a small app I built to make one everyday annoyance disappear.

If you build apps or websites, you've probably seen it: you try to start your project and it says the port is already in use. A port is just the doorway an app uses to talk to your computer, and something else is quietly sitting in it. Finding out what usually means a trip down a rabbit hole.

Porter shows you everything in one simple window:

• See which ports are free and which are taken, updated live

• Find out which app is using a port

• Close anything that's stuck with one click

• Pin the ports you use most so they're always at the top • Search instantly • Switch between a clean dark mode and light mode

• Make everything bigger or smaller to suit your screen • Get notified when a new version is out

It works on Windows, Mac and Linux, it's light on your computer, and it's completely free.

This is the first public release, so I'd really love your feedback. What's missing, what's confusing, what would you want next?

Download it here: https://github.com/t21dev/porter-app/releases/latest

#Porter #OpenSource #FreeApp #t21dev