# AI-assisted app change

This tutorial walks you through modifying a Comind.work app using Claude Code with the apps-dev skill. You will change a field caption, add a visibility rule, and deploy the result - all through natural language instructions to Claude.

By the end you will have a working change deployed to a development workspace, and a clear picture of the describe-modify-deploy loop that makes AI-assisted development practical.

## Prerequisites[​](#prerequisites "Direct link to Prerequisites")

Before starting, make sure you have:

* A working development environment - [local](/developer-guide/getting-started/local-environment.md) or [GitHub Codespaces](/developer-guide/getting-started/github-codespaces.md)
* Claude Code installed with the comind-dev plugin - [setup guide](/developer-guide/getting-started/claude-code-setup.md)
* Environment variables configured - [environment variables](/developer-guide/getting-started/environment-variables.md)
* At least one app installed in a development workspace (e.g. a task or ticket app)

## Step 1: Open your project and invoke the skill[​](#step-1-open-your-project-and-invoke-the-skill "Direct link to Step 1: Open your project and invoke the skill")

Open your app repository in Claude Code (the Desktop app, VS Code extension, or terminal). Then invoke the apps-dev skill on the app you want to modify:

```
/apps-dev app-org-task
```

Replace `app-org-task` with the folder name of your app. If you are not sure which apps are available, ask Claude:

```
What apps are in this repository?
```

Claude scans the app folder and reads its fields, actions, layouts, and settings. Once loaded, it understands the app's structure and can answer questions or make changes.

tip

If the slash command is not recognized, you can load the skill file directly:

```
@SKILL.md app-org-task
```

See [Claude Code setup - working with skills](/developer-guide/getting-started/claude-code-setup.md#working-with-skills) for details.

## Step 2: Change a field caption[​](#step-2-change-a-field-caption "Direct link to Step 2: Change a field caption")

Ask Claude to rename a field caption in plain language. For example:

> Change the caption of the `c_priority` field to "Urgency level"

Claude will:

1. Open `fields/index.ts`
2. Find the field definition for `c_priority`
3. Update the `caption` property from its current value to `Urgency level`
4. Show you the exact change it made

The diff looks something like this:

fields/index.ts

```
{
    caption: 'Urgency level',  // was 'Priority'
    name: 'c_priority',
    type: 'lookup',
    lookupName: 'c_priority_options',
},
```

Review the change. If it looks right, move on. If not, tell Claude what to adjust - it keeps the full context of the conversation.

## Step 3: Add a visibility rule[​](#step-3-add-a-visibility-rule "Direct link to Step 3: Add a visibility rule")

Now ask Claude to add conditional field visibility:

> Hide the `c_internal_notes` field from users who are not workspace admins

Claude will:

1. Open (or create) `views/logic/index.ts`
2. Add a `getInvisibleFields` function that checks the current user's role
3. Return the field name when the condition is met

The generated code follows the standard view logic pattern:

views/logic/index.ts

```
import type { EntityFieldName } from '#typings';
import { entity } from '#typings';
import type { ViewLogic } from '@comind/api';

export default {
    getInvisibleFields,
} satisfies ViewLogic<typeof entity>;

function getInvisibleFields() {
    const fields: EntityFieldName[] = [];
    if (!ComindView.currentUser.isWorkspaceAdmin) {
        fields.push('c_internal_notes');
    }
    return fields;
}
```

If the file already exists with other view logic methods, Claude merges the new function into the existing export rather than overwriting it.

info

`ComindView.currentUser` provides the logged-in user's context at runtime. The `isWorkspaceAdmin` property is `true` when the user has admin rights in the current workspace. See [view logic](/developer-guide/building-blocks/view-logic.md) for all available methods and properties.

## Step 4: Deploy and verify[​](#step-4-deploy-and-verify "Direct link to Step 4: Deploy and verify")

Ask Claude to deploy the modified app to a development workspace:

> Deploy this app to the CRM workspace

Claude runs the install command:

```
npx comind install app-org-task CRM
```

The output confirms whether the deployment succeeded. If this is the first time the app is installed in that workspace, the command both compiles and installs it. If the app was already installed, the workspace picks up the update automatically.

To verify your changes:

1. Open your development site in a browser (e.g. `https://your-org-dev.comindwork.com`)
2. Navigate to the CRM workspace
3. Open any record in the app
4. Confirm the field caption now reads "Urgency level"
5. Log in as a non-admin user and confirm that `c_internal_notes` is hidden

## Step 5: Iterate[​](#step-5-iterate "Direct link to Step 5: Iterate")

AI-assisted development shines when you need to refine a change. Continue the conversation naturally:

> Actually, make the internal notes visible to members of the Team group too

Claude updates the visibility condition to check for group membership alongside admin status, then you redeploy:

> Deploy again to CRM

Each iteration follows the same loop: describe the change, review Claude's edit, deploy, verify. Because the skill keeps the app's full context loaded, Claude remembers previous changes and builds on them without losing track.

If something goes wrong, you can always ask Claude to revert:

> Undo the last change to the visibility rule

All changes are local files in your repository until you commit and push.

## What you learned[​](#what-you-learned "Direct link to What you learned")

* How to invoke the apps-dev skill on a specific app folder
* How Claude reads and modifies app code - fields, view logic, and deployment
* The describe-modify-deploy-verify cycle
* How to iterate on changes through conversation
* That all changes are local files you can review, commit, or revert before they reach production

## Next steps[​](#next-steps "Direct link to Next steps")

* [Git workflow](/developer-guide/getting-started/git-workflow.md) - commit your changes and understand the branch strategy
* [Fields and field options](/developer-guide/building-blocks/fields-and-field-options.md) - learn about data types and field configuration
* [View logic](/developer-guide/building-blocks/view-logic.md) - visibility, requiredness, and lifecycle hooks in depth
* [Common mistakes](/developer-guide/how-to/common-mistakes.md) - avoid frequent pitfalls when developing apps