Early 2026 I had built around 17 agents in Claude code: a PM, frontend lead, designer, QA, GTM, and others, with one project-manager agent orchestrating them by tagging and maintaining a task board in Markdown. It was working, but maintaining the agents became one of the tasks alongside my other work. Open-source skills and plugins had moved faster and well maintained, so I switched from the sub-agent set up.

The principle that makes the current setup work is that every decision, every plan, and every completed item is dropped into a structured docs folder as a Markdown file. Skills and agents downstream pick them up automatically without me having to re-explain anything.

Spec phase

For any feature to be built, I currently spend more time on specs and planning before diving into the code. The spec phase skills are from Garry Tan’s gstack

/office-hours for the initial spec. It pushes back on premises and stops me from implementing unnecessary stuff by making me rethink. Two modes, builder for side projects, startup for real product work.

/plan-ceo-review for scope expansion. Brings in easy wins and expands the spec where it makes sense.

/plan-eng-review to check engineering feasibility on what came out of the previous step.

/plan-design-review goes through the spec with seven passes. interaction states, responsiveness, a11y, unresolved decisions. Rates each 0–10 and fixes the plan inline.

Once these skills have run, I do a second opinion pass on the spec. Either a new Claude subagent or /codex (OpenAI’s Codex CLI). Catches issues and mistakes the first pass missed. Different model, different blind spots, adversarial by design.

/design-consultation only for new projects. Builds a complete design system from scratch and writes design.md

Design exploration

Before going to Claude Code I usually pull inspiration from a few AI design tools. Lovable, Replit, bolt.new, and Google Stitch each generate different takes on the same spec, and seeing 4–5 variants across tools gives me a sense of the design space before committing to a direction. None of these end up in the codebase. They’re reference points.

For specific components I’m unsure about, I check Mobbin and Dribbble for existing patterns. There’s also the option of connecting Figma or Pencil directly to Claude. I haven’t explored that much yet.

/design-shotgun generates three variants and opens a comparison board in Chrome. The advantage over the external tools is context. Shotgun already knows my design.md, so the variants come back aligned with existing tokens, components, and voice.

When the design direction itself is still unclear, I sometimes use /superpowers:brainstorm in Claude’s plan mode. It’s more conversational and helps me think through what I want before jumping to variants.

Planning and Implementation

For Planning and Building, most of the skills I use are from superpowers. I discovered this in the beginning of March. And it’s actually super powerful.

/superpowers:write-plan in Claude’s plan mode. Reads every doc generated above and breaks the spec into bite-sized tasks of 2–5 minutes each, with file paths and tests written down. When work can be parallelized it splits into subtrees. Some of my specs have come out as 50 bite-sized tasks across 3 parallel subtrees.

/superpowers:execute-plan is where coding starts. By this point most of the issues have been planned away so there are fewer surprises during implementation. I run it in subagent-driven-development mode and can walk away. Questions that come up can be addressed through Claude’s /remote-control from mobile. But if it is a brand new repository. We could run with — dangerously-skip-permissions. So it works autonomously. (Yeah that needs to be used with caution)

One rule I give it upfront: use Opus for critical tasks and anything that needs real reasoning. Use Sonnet for small, straightforward execution. Don’t use Haiku. Haiku is fast but not meant for code that’s going to ship, not worth the savings.

Reviews: For every task or task group, three reviewers run before anything gets accepted. A spec review checks the work matches what was planned. A code quality review checks for the usual things, structure, naming, edge cases, test coverage. A UX review checks the user-facing behavior.

Worth knowing: even on the Max plan, subagent-driven-development can hit rate limits. Sometimes, when I reach the limits in the day. Have run Claude overnight autonomously providing all the steps and documents it needs to refer.

Polish and Iterate

/design-review from gstack runs an 80-item visual audit on the live site, then enters a fix loop with one atomic commit per finding and before/after screenshots.

/ui-ux-pro-max is the alternative for design intelligence. Its database has 50+ styles, accessibility rules, and color systems, and it’s better when I want to apply a design direction than for raw audit. [ui-ux-pro-max]

Claude Cowork has design skills too for critique and accessibility audits, useful for a different lens.

Run a second iteration of planning and building with Superpowers. Same flow, smaller scope, fixes from the audit baked in. This creates a loop of iteration.

Another well-maintained option is Affaan Mustafa’s everything-claude-code, an Anthropic Hackathon winner with around 180 skills and 48 agents. Have recently started exploring some skills from it. Have used /security-review and /harness-audit from it. Can be used as an alternative to Superpowers for build.

The harness around the loop

For everything to run with less human in the loop, the supporting files have to do real work.

CLAUDE.md for standard decisions and commands. DESIGN.md for the current design system. Decisions get promoted to docs/decisions/ADR-*.md. Each spec and Superpowers plan gets its own folder. Every feature on its own branch and worktree.

All commits and pushes go through Claude. A custom /commit skill batches related changes, scopes them properly, and writes meaningful messages. Before pushing, Claude reviews its own diff for analytics and logging on new code paths and flags obvious security issues.

Husky pre-push hooks run the deterministic layer on top: unit tests, e2e tests, and functional tests through Playwright MCP or Chrome MCP.

Routines

Claude Code Routines are like automated agents performing everyday tasks based on API or time based like cron by chaining MCPs with custom skills from the repo. Daily research, outreach to generate business leads, auto-triaging new issues from the issue list. For engineers, that last one alone is meaningful time recovery.

For CricCheer, I have a /update-scores skill that pulls from Google and updates scores and the points table in the database. A routine fires it at the end of every IPL match. Zero maintenance from me.

The number of possibilities here is large. Worth a separate write-up of its own.

If you read this far and want more on Claude Code and building systems around AI, follow along.

How to create a Custom GPT?

We can walk along and build a code migration bot. We developers generally have many code migration tasks, it could be from one language to another. From one version of the programming language to other. Or may be migrating from one framework to another. For now, we will be building a generic GPT. It can be customized based on needs.

Access to the GPT Builder

We would need access to GPT Builder. At the time of this blog, the access was currently only to GPT Plus subscribers. If you already have access, you can directly go to the following Custom GPT link.

You can click on Explore under the New Chat sidebar and click on Create a GPT option.

Name your GPT

Select a name that is both descriptive and memorable. It should reflect the purpose of your GPT. You could generate this using chatgpt as well.

For the code migration bot, Let us name it Code Migrate Pro.

Define Your GPT's Purpose

Articulate the GPT: Clearly define what your GPT is intended to do. This helps in designing its functionalities and training it appropriately.

Code Migrate Pro is a GPT that takes in code as input, it could be in the form of text or a file attached. If GPT can parse the file or understand the language and framework from the text paster. We should directly ask the user for their target language or framework. If we already have the target language or framework the input needs to be translated to. We should go ahead with the migration.

Tone: Decide on the tone of interaction. It could be anything. Friendly, Casual, Humorous and Professional.

Let us keep the tone of this GPT witty and geeky.

What to avoid: What do we need to avoid? GPT generally goes back to its default behavior. we need to override some of its default behavior by explicitly mentioning what we need to avoid. Or if the user asking questions that are not relevant to this GPT. How do we handle it?

When user inputs the code, we should not go about explaning the meaning of the code. We should always ask the users for their target language to migrate. As you are only a Migration bot. But, if you don't have clarity of target language or framework you can ask for that information.

How to handle ambiguity? When GPT has some ambiguity like in the above case. If the user asks to migrate code from Angular or Vue to React. Should we assume some of the things like how to handle styles, should they be inline css, or styled-components. Are we using typescript or not? If there is a route in the code, how to handle the router? Should we use react-router? How do we handle the data? redux or context?

When we have a minor ambiguity, we try to assume the industry standard way of doing the things and migrate the code given. But at the end of the output we can also need to provide other alternatives that can be considered. If there are large number of unknowns in the code, let us post all the questions to the user. We also need to remember all the answers we collect from the user for this particular session. So that if user tries to post any other code sample. We should not repeat the same questions.

Gather Relevant Data

Collect data relevant to your GPT’s function. This could include text samples, datasets, FAQs, etc. We can make our GPT focus on one particular thing and do it well by gathering the knowledge base and uploading it as knowledge files. Imagine if we were only migrating code from python 2 to python 3. We can upload some cheatsheets as the knowledge file.

And if we are building a code review bot, we can upload the internal eslint file or company standard coding guidelines. Which could serve as a bot that reviews the code at a high level.

In the case of code migration bot, the intention is to create a generic GPT. Which will serve as a saved prompt saving the time required to set the context.

Testing and Fine-Tuning

We should be testing our GPT with all the use cases we wish to cover with this particular GPT. We should be providing sample queries as well. If we find that the GPT is not able to resolve any query with expected solution. We can resolve the same by fine-tuning. In custom GPTs, we can either fine-tune by asking GPT to change its behavior in the GPT Builder or upload more knowledge files.

Authentication

For some GPTs we might need users to authenticate before we perform any operation. This can be used when the data we have in the knowledge files should not be accessible to someone unauthenticated. While configuring GPT, you can click on Add Actions and select Authentication to use the allowed authentication methods.

Lets now see the demo of the Code Migrate Pro we built along with other two GPTs.

Code Migrate Pro

Here's the link to the GPT if you have access and want to give it a try.

https://chat.openai.com/g/g-mGetr9JOB-code-migrate-pro

Demo:

UnitTest Genie

Link to GPT: https://chat.openai.com/g/g-JceDeX8FA-unittest-genie

Demo:

Component Builder

Link to GPT: https://chat.openai.com/g/g-jii0rFNxq-component-builder

Demo:

Here's a sample prompt that can be used to start building a GPT like component builder.

You are a component creator. Whenever a user uploads a image of a mockup. You ask them, which frontend stack they want the mockup to be created. It can be React, Next, Svelte, JavaScript or Mobile app. If we do not know the the stack, we ask the user to input the stack. Once we know the stack, we directly dive into generating the code. Always try to keep the code production quality. Before generating styles. We should ask the users what is their style preference, styled-components, picocss, tailwind, material, bootstrap etc. Lets assume the consumers are frontend engineers with some experience. Do not explain the code unless the user asks for more information. Always try to keep the conversation, light witty and geeky.

We will continue this series by learning more about GenAI and how it could impact various fields in upcoming blogs.

Do try out the below Custom GPTs and let me know in the comments how it turned out. Did they meet the expectations? Do suggest if you think anything can be better or suggestions on other innovative GPTs that can be built.

In the ever-evolving landscape of artificial intelligence, OpenAI recently introduced a groundbreaking development just a few days before the boardroom drama: 'Custom GPTs', a version of ChatGPT, or simply what they call 'GPTs'. Over the last couple of weeks, I have been delving into the potential of these customized GPTs. Meanwhile, Amazon has also launched a similar feature called PartyRock. This blog is the first in a multi-part series where we will explore what customized GPTs are and their potential use cases, In the coming parts we will be exploring how to create a custom GPT along with some of the custom GPTs I have developed in the process.

Problem

ChatGPT, which uses Large Language Models(LLM) like GPT-4 or GPT-3.5, is already one of the most powerful AI tools, used by millions of end-users every day. When interacting with ChatGPT, they often need to provide extensive context in their prompts or follow up with multiple prompts to extract the desired or optimal output. This can be time-consuming, especially for those seeking quick and precise answers.

Small applications built using APIs on top of GPT models must create pre-trained models that incorporate the necessary context and data specific to their application's focus.

This involves not just mastering the art of prompt engineering but also managing the costs associated with these models. Using GPT-4 costs approximately $0.06 per 1,000 tokens.

What are Custom GPTs

Custom GPTs represent a new approach to creating mini GPTs tailored for specific use cases.

Custom GPTs can be as simple as using your already saved prompts that you reuse daily. By providing these as a context, they function as a form of custom GPT, enabling users to quickly obtain the results they need without repetitive prompting.

Users also gain the ability to store context and upload significant amounts of data, up to 20 knowledge files of 512 MB each. This feature is particularly beneficial for small applications and power users, providing the necessary depth of data for more specialized and accurate results.

What truly makes Custom GPTs remarkable is their accessibility. The creation of a custom GPT isn't limited to developers or tech experts. OpenAI has democratized the GPT creation process, allowing all end users to craft their own Custom GPTs. This is facilitated by the GPT builder, a tool that simplifies the process, requiring users to provide just a prompt to begin creating their personalized AI model. More details about this will be discussed in later sections.

GPTs Store

Currently, despite the presence of multiple models like BERT, Claude, PaLM, and LLaMA, GPT-4 has emerged as the most reliable choice in the GenAI landscape and for projects built on top of LLMs. Many likened ChatGPT's unveiling last year to an 'iPhone moment' in the AI industry when it reached a million users in just 5 days.

But how exactly do these mini GPTs compare to the App Store? As of now, you can access Custom GPTs via a direct URL, and some popular GPTs are featured on the discovery page which can be found by clicking on Explore in the sidebar. OpenAI will soon be launching a GPT Store. This platform will enable not only the sharing of custom GPTs but also provide creators with the opportunity to monetize their models through a revenue-sharing model. This initiative is expected to boost the development of GPTs, similar to how mobile app development surged in the past.

Practical Applications and Benefits of Custom GPTs

Where can we use Custom GPT? Listing down some of the usecases I can think of, along with some usecases I have encountered while exploring GPTs created by other users.

Disclaimer: I understand many of these can also be created by building a pretrained models on top of other LLMs. I'm just trying to list down the ones that can be built with GPT Builder via prompts and knowledge files.

Organization Use Cases

• Customer Service and FAQs: Companies can upload their entire FAQ database to a custom GPT. Then, this custom GPT can be shared via a URL, or it can be integrated into the company's bot for better customer service.

• Internal HR Bot: Companies often have a ton of HR policies. By uploading all these policies and creating a custom GPT, employees can gain quick and easy access to the information they need. (But yeah need to ensure the information is accessible only to employees)

• Data Analysis: We can train the custom GPT model to recognize and analyze data, thereby providing insights that aid in faster and more accurate decision-making. This approach is particularly helpful for businesses that need to understand complex data, ultimately enhancing operational efficiency.

General Use Cases

• Cooking and Recipe Generation: Create a GPT model trained in culinary arts, incorporating a wide array of recipes from around the world. This model, when given a list of available ingredients, could quickly suggest multiple recipes.

• Educational Tools: Custom GPTs can be tailored to specific educational subjects or languages. Imagine a GPT model fine-tuned with particular textbooks or subjects, assisting students in understanding complex concepts or practicing a new language.

• Legal and Medical Assistance: Lawyers and medical professionals often need quick access to a wealth of references. Custom GPTs, fine-tuned with legal or medical texts, can aid these professionals by providing rapid references and suggestions based on specialized knowledge bases.

• Travel Planner: By training a custom GPT with the best travel itineraries as knowledge files, users can receive tailor-made holiday suggestions based on their preferences.

• Agricultural Advisor: A custom GPT could be trained with regional weather patterns and market demands to provide farmers with insights about the most suitable crops for a given season and market.

• Finance Planning: Customized to individual financial situations and goals, a custom GPT could offer advice on budgeting, investment strategies, and retirement planning.

• Copy Checker: We can have a custom GPT designed to assist with everyday writing. Its primary function isn't to change sentences but to check for spelling and grammatical errors. This tool would be invaluable for enhancing our day-to-day written communications, including social media posts, emails, blogs, and more, ensuring they are polished and professional.

Personal Use Cases

• Personalized Book Companions: By uploading book contents, custom GPTs can be created to serve as interactive companions for readers. These GPTs can answer questions, discuss themes, and provide analysis, enhancing the reading experience.

• Personal Assistants: If you maintain a digital diary or a 'second brain' on Notion or any other note-taking app, this can serve as a knowledge base for a custom GPT. Imagine a custom GPT trained on this data, encompassing your personal preferences, schedules, and tasks. Such a GPT could act as a highly personalized assistant, aiding in daily decision-making.

• Personal Motivator: If you have favorite authors or books that inspire you, they can serve as knowledge files for a custom GPT. This model could help you find motivation using quotes or themes from these sources, be it Dale Carnegie's books, Naval Ravikant's tweets, or the Bhagavad Gita.

• Personal Design Critique: A custom GPT can act as a critique for any uploaded design and provide suggestions based on knowledge files. These files could include works from your favorite artists or standard design patterns.

Developer Use Cases

Custom GPTs come equipped with a code interpreter, enabling users to directly attach a file in any programming language as input.

• Software Migration: As developers, we often have numerous modernization tasks at hand. This could involve migrating code from one language to another, or from one framework to another, such as Angular to React/Next, or even upgrading from one version to another, like Python 2 to 3. We can create a custom GPT with prompts for this task, along with cheat sheets for the most commonly used migrations as knowledge files.

• Unit Tests: Writing unit tests can be quite a tedious task for many developers, yet they are vital for preventing future bugs and issues as the code evolves. Creating a custom GPT for this purpose would be hugely beneficial. Such a GPT could generate extensive unit tests covering all possible cases, simply by uploading or pasting a file. This would not only save time but also enhance the quality and thoroughness of the testing process.

• Mockup to Component: For frontend developers, who often need to convert Figma files to frontend components, or for those who are prototyping an application, a custom GPT could be a game-changer. Imagine a GPT that can swiftly convert mockups into React, Svelte, vanilla JS, or any frontend stack of choice.

• Code Documentation: Writing documentation for code on platforms like GitHub (in the ReadMe) or on Confluence is a regular necessity. We can simplify this process by creating a custom GPT with specific prompts tailored for documentation purposes.

In the next part of this blog series, we will focus on understanding how to create a custom GPT. Additionally, we'll dive deeper into some of the use cases discussed earlier. This exploration will involve building custom GPTs to showcase their practical applications and demonstrate their effective utilization in various scenarios.