mobilelauncher
Skill34 starsChanged 5 months agoMITView on GitHub
MobileLauncher LT project skill. Generates boilerplate-consistent code: new features, screens, components, hooks, Redux slices, RTK Query endpoints, and Zod schemas — all following the feature-first architecture, Restyle styling, and TypeScript strict rules of this repo. Use when adding anything new to this codebase.
In this repository17 other files it gives its agents.
- AGENTS.mdAGENTS.md
- CLAUDE.mdCLAUDE.md
- .cursor/rules/app_feature_first_architecture.mdcCursor rule
- .cursor/rules/app_rules.mdcCursor rule
- .cursor/rules/best_practices.mdcCursor rule
- spec-harness-auditSkill
- spec-harness-buildSkill
- spec-harness-generate-agentsSkill
- spec-harness-installSkill
- spec-harness-learnSkill
- spec-harness-planSkill
- spec-harness-rulesSkill
- spec-harnessSkill
- spec-harness-specSkill
- spec-harness-tasksSkill
- spec-harness-ticketsSkill
- spec-harness-verifySkill
The file
Show its rules and text
We split this skill into the rules it gives an agent
21 rules. About 0 are common, 6 are distinctive, and 15 are very specific to this project.
≈0
Common · estimate
Many files like this have a rule of this kind.
≈6
Distinctive · estimate
This author's own choices. Worth a look.
15
Very specific
Tied to their project's names, files or tools. Probably skip.
- Common
- Distinctive
- Very specific
- Distinctive: line 19
Before generating anything, you have already internalized:
- Very specific: line 35
Read $ARGUMENTS and identify the command:
- Distinctive: line 47
If arguments are ambiguous, ask one clarifying question before proceeding.
- Distinctive: line 53
Before generating any code, always read the relevant existing files to match patterns exactly:
- Distinctive: line 361
After creating all files, remind the user to:
- Very specific: line 362
Add <name>Reducer to src/store/reducers.ts
- Very specific: line 363
Add '<Name>' to tagTypes in src/services/api/api.ts if new tag type needed
- Very specific: line 364
Add routes to src/navigation/routes.ts and src/navigation/routes.types.ts
- Very specific: line 365
Add translation keys to src/locales/en.json and src/locales/fr.json
- Very specific: line 371
Read the existing feature's screens/ directory first to match patterns.
- Very specific: line 406
Read src/ui/components/ for existing component patterns first.
- Distinctive: line 456
Ask: "Is this hook feature-scoped or shared across features?"
- Very specific: line 490
Read the existing feature's types/index.ts first to know the state shape.
- Very specific: line 492
Create src/features/<feature>/store/<feature>.slice.ts — follow the same template as in feature command above, adapted to the existing …
- Very specific: line 502
Create or append to src/features/<feature>/api/<feature>.api.ts:
- Distinctive: line 550
After generating any code, output this checklist with only the items relevant to what was generated:
- Very specific: line 571
No inline styles: style={{ ...
- Very specific: line 572
No hardcoded values: padding={16}, backgroundColor="#fff" — use theme tokens
- Very specific: line 576
No cross-feature imports — features only import from #services/, #ui/, #utils/, #store/
- Very specific: line 578
No hardcoded strings in JSX — t('key') always
- Very specific: line 579
No missing barrel exports — every generated file gets exported from the feature's index.ts
≈ “Common” is an estimate: at least 1 in 5 of the 372,429 skill files we read have a rule of the same kind, not the same words. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.
Files
MobileLauncher LT — Project Skill
You are an expert React Native engineer who knows this codebase inside-out. Your job is to generate code that is indistinguishable from existing code in this repo — same patterns, same conventions, same file structure, zero drift.
Before generating anything, you have already internalized:
- Feature-first architecture: code organized by business feature, never by technical layer
- Restyle for all styling: no StyleSheet, no inline styles, no hardcoded values
- Redux Toolkit + RTK Query: typed hooks, createSelector, endpoint injections
- TypeScript strict: no any, no ts-ignore, explicit types everywhere
- i18next for all visible text: no hardcoded strings in JSX
- FlashList for lists: never FlatList
- MMKV for storage: never AsyncStorage for new code
- Biome for formatting: run lint:fix after generating files
Arguments received: $ARGUMENTS
Step 1: Parse Command
Read $ARGUMENTS and identify the command:
feature <name>— scaffold a complete new feature directory with all filesscreen <feature> <name>— add a screen to an existing featurecomponent <name>— generate a shared Restyle UI component insrc/ui/components/hook <name>— generate a custom hook (ask if feature-scoped or shared)slice <feature>— generate a Redux slice + selectors for a featureendpoint <feature> <name>— generate an RTK Query endpoint injectionschema <name>— generate a Zod schema insrc/schemas/orient— read the project and give a concise orientation report- (no args or unrecognized) — show the available commands and ask what to generate
If arguments are ambiguous, ask one clarifying question before proceeding.
Step 2: Read Current State
Before generating any code, always read the relevant existing files to match patterns exactly:
For any generation task, read:
CLAUDE.md— rules and constraintsboilerplate_content.md— full architecture reference- One existing similar file (e.g., if adding a screen, read an existing screen in the same feature)
For orient: additionally read src/features/ directory listing, package.json, and src/store/store.ts.
Step 3: Execute Command
orient
Read:
CLAUDE.mdboilerplate_content.mdpackage.json(versions)src/features/directory listingsrc/store/reducers.ts
Report back in this format:
## MobileLauncher LT — Orientation
**Expo:** <version> · **React Native:** <version> · **React:** <version>
**Features:** <list of src/features/ directories>
**Registered reducers:** <list from reducers.ts>
**Path aliases:** #root, #features, #ui, #services, #utils, #config, #navigation, #store
**Key rules (5-second version):**
- Styling: Restyle only — no StyleSheet, no inline styles
- State: useAppSelector / useAppDispatch, createSelector, RTK Query
- Storage: MMKV for app data, SecureStore for sensitive data
- Lists: FlashList, never FlatList
- Text: t() from i18next, no hardcoded strings
- Types: strict, no any
**Memory bank:** ai_articles/memory-bank/ — read systemPatterns.md for architecture decisions
**To generate code, run:** /mobilelauncher feature|screen|component|hook|slice|endpoint|schemafeature <name>
Scaffold a complete new feature. Use <name> in kebab-case for files, PascalCase for types.
Directories to create:
src/features/<name>/
api/
components/
hooks/
screens/
services/
store/
types/Files to create:
src/features/<name>/types/index.ts
export interface <Name> {
id: string;
// add fields relevant to this feature
createdAt: string;
updatedAt: string;
}
export interface <Name>State {
items: <Name>[];
selectedId: string | null;
isLoading: boolean;
error: string | null;
}src/features/<name>/store/<name>.slice.ts
import { createSlice, createSelector, type PayloadAction } from '@reduxjs/toolkit';
import type { RootState } from '#store/store';
import type { <Name>, <Name>State } from '../types';
const initialState: <Name>State = {
items: [],
selectedId: null,
isLoading: false,
error: null,
};
const <name>Slice = createSlice({
name: '<name>',
initialState,
reducers: {
setItems: (state, action: PayloadAction<<Name>[]>) => {
state.items = action.payload;
},
setSelectedId: (state, action: PayloadAction<string | null>) => {
state.selectedId = action.payload;
},
setLoading: (state, action: PayloadAction<boolean>) => {
state.isLoading = action.payload;
},
setError: (state, action: PayloadAction<string | null>) => {
state.error = action.payload;
},
reset: () => initialState,
},
});
export const { setItems, setSelectedId, setLoading, setError, reset } = <name>Slice.actions;
export const <name>Reducer = <name>Slice.reducer;
// Selectors
const select<Name>State = (state: RootState) => state.<name>;
export const select<Name>Items = createSelector(select<Name>State, (s) => s.items);
export const select<Name>SelectedId = createSelector(select<Name>State, (s) => s.selectedId);
export const select<Name>IsLoading = createSelector(select<Name>State, (s) => s.isLoading);
export const select<Name>Error = createSelector(select<Name>State, (s) => s.error);
export const select<Name>Selected = createSelector(
select<Name>Items,
select<Name>SelectedId,
(items, id) => items.find((item) => item.id === id) ?? null,
);src/features/<name>/store/index.ts
export * from './<name>.slice';src/features/<name>/api/<name>.api.ts
import { api } from '#services/api/api';
import type { <Name> } from '../types';
const <name>Api = api.injectEndpoints({
overrideExisting: true,
endpoints: (builder) => ({
get<Name>s: builder.query<<Name>[], void>({
query: () => '/<name>s',
providesTags: ['<Name>'],
}),
get<Name>ById: builder.query<<Name>, string>({
query: (id) => `/<name>s/${id}`,
providesTags: (_result, _error, id) => [{ type: '<Name>', id }],
}),
create<Name>: builder.mutation<Omit<<Name>, 'id' | 'createdAt' | 'updatedAt'>, <Name>>({
query: (body) => ({ url: '/<name>s', method: 'POST', body }),
invalidatesTags: ['<Name>'],
}),
update<Name>: builder.mutation<Partial<Omit<<Name>, 'id' | 'createdAt' | 'updatedAt'>>, { id: string } & <Name>>({
query: ({ id, ...body }) => ({ url: `/<name>s/${id}`, method: 'PATCH', body }),
invalidatesTags: (_result, _error, { id }) => [{ type: '<Name>', id }],
}),
delete<Name>: builder.mutation<void, string>({
query: (id) => ({ url: `/<name>s/${id}`, method: 'DELETE' }),
invalidatesTags: ['<Name>'],
}),
}),
});
export const {
useGet<Name>sQuery,
useGet<Name>ByIdQuery,
useCreate<Name>Mutation,
useUpdate<Name>Mutation,
useDelete<Name>Mutation,
} = <name>Api;src/features/<name>/api/index.ts
export * from './<name>.api';src/features/<name>/hooks/use-<name>.ts
import { useCallback } from 'react';
import { useAppDispatch, useAppSelector } from '#store/store';
import {
select<Name>Items,
select<Name>IsLoading,
select<Name>Error,
select<Name>Selected,
setSelectedId,
reset,
} from '../store';
import { useGet<Name>sQuery } from '../api';
export const use<Name> = () => {
const dispatch = useAppDispatch();
const items = useAppSelector(select<Name>Items);
const selectedItem = useAppSelector(select<Name>Selected);
const isLoading = useAppSelector(select<Name>IsLoading);
const error = useAppSelector(select<Name>Error);
const { isFetching } = useGet<Name>sQuery();
const selectItem = useCallback(
(id: string | null) => {
dispatch(setSelectedId(id));
},
[dispatch],
);
const resetFeature = useCallback(() => {
dispatch(reset());
}, [dispatch]);
return {
items,
selectedItem,
isLoading: isLoading || isFetching,
error,
selectItem,
resetFeature,
};
};src/features/<name>/hooks/index.ts
export * from './use-<name>';src/features/<name>/screens/<name>-list-screen.tsx
import React, { useCallback } from 'react';
import { useTranslation } from 'react-i18next';
import { FlashList } from '@shopify/flash-list';
import { Box, Text } from '#ui/components';
import { use<Name> } from '../hooks';
import type { <Name> } from '../types';
const <Name>ListScreen = () => {
const { t } = useTranslation();
const { items, isLoading } = use<Name>();
const renderItem = useCallback(
({ item }: { item: <Name> }) => (
<Box
padding="md"
marginBottom="sm"
backgroundColor="surface"
borderRadius="md"
>
<Text variant="body">{item.id}</Text>
</Box>
),
[],
);
if (isLoading) {
return (
<Box flex={1} justifyContent="center" alignItems="center">
<Text variant="body">{t('common.loading')}</Text>
</Box>
);
}
return (
<Box flex={1} backgroundColor="background">
<FlashList
data={items}
renderItem={renderItem}
estimatedItemSize={80}
contentContainerStyle={{ padding: 16 }}
/>
</Box>
);
};
export default React.memo(<Name>ListScreen);src/features/<name>/screens/index.ts
export { default as <Name>ListScreen } from './<name>-list-screen';src/features/<name>/components/index.ts
// Feature-specific components export heresrc/features/<name>/services/index.ts
// Feature business logic and data transforms export heresrc/features/<name>/index.ts
export * from './api';
export * from './hooks';
export * from './screens';
export * from './store';
export type * from './types';After creating all files, remind the user to:
- Add
<name>Reducertosrc/store/reducers.ts - Add
'<Name>'totagTypesinsrc/services/api/api.tsif new tag type needed - Add routes to
src/navigation/routes.tsandsrc/navigation/routes.types.ts - Add translation keys to
src/locales/en.jsonandsrc/locales/fr.json
screen <feature> <name>
Read the existing feature's screens/ directory first to match patterns.
Create src/features/<feature>/screens/<name>-screen.tsx:
import React, { useCallback } from 'react';
import { useTranslation } from 'react-i18next';
import type { StackNavigationProp } from '@react-navigation/stack';
import { useNavigation } from '@react-navigation/native';
import { Box, Text } from '#ui/components';
import type { RootStackParamList } from '#navigation/routes.types';
type <Name>ScreenNavigationProp = StackNavigationProp<RootStackParamList, '<Name>'>;
const <Name>Screen = () => {
const { t } = useTranslation();
const navigation = useNavigation<<Name>ScreenNavigationProp>();
return (
<Box flex={1} backgroundColor="background" padding="md">
<Text variant="h1">{t('<feature>.<name>.title')}</Text>
</Box>
);
};
export default React.memo(<Name>Screen);Export from src/features/<feature>/screens/index.ts.
Remind user to register the route in routes.ts and routes.types.ts.
component <name>
Read src/ui/components/ for existing component patterns first.
Create src/ui/components/<name>.tsx:
import React, { useCallback } from 'react';
import { createBox, createText, useTheme } from '@shopify/restyle';
import type { Theme } from '#ui/style/theme';
const Box = createBox<Theme>();
const TextComponent = createText<Theme>();
export interface <Name>Props {
// define props
onPress?: () => void;
disabled?: boolean;
}
const _<Name> = ({ onPress, disabled = false }: <Name>Props) => {
const theme = useTheme<Theme>();
const handlePress = useCallback(() => {
if (!disabled && onPress) {
onPress();
}
}, [onPress, disabled]);
return (
<Box
backgroundColor="surface"
padding="md"
borderRadius="md"
opacity={disabled ? 0.5 : 1}
>
<TextComponent variant="body" color="textPrimary">
{/* content */}
</TextComponent>
</Box>
);
};
export const <Name> = React.memo(_<Name>);Export from src/ui/components/index.ts (add the named export).
hook <name>
Ask: "Is this hook feature-scoped or shared across features?"
Feature-scoped → src/features/<feature>/hooks/use-<name>.ts
Shared → src/ui/hooks/use-<name>.ts
Template:
import { useState, useCallback, useEffect } from 'react';
export interface Use<Name>Options {
// options
}
export interface Use<Name>Return {
// return shape
isLoading: boolean;
error: string | null;
}
export const use<Name> = (options?: Use<Name>Options): Use<Name>Return => {
const [isLoading, setIsLoading] = useState(false);
const [error, setError] = useState<string | null>(null);
return {
isLoading,
error,
};
};slice <feature>
Read the existing feature's types/index.ts first to know the state shape.
Create src/features/<feature>/store/<feature>.slice.ts — follow the same template as in feature command above, adapted to the existing types.
Remind user to register the reducer in src/store/reducers.ts.
endpoint <feature> <name>
Read src/features/<feature>/types/index.ts first.
Create or append to src/features/<feature>/api/<feature>.api.ts:
// Inject into existing api variable, or create new injectEndpoints call
const <feature>Api = api.injectEndpoints({
overrideExisting: true,
endpoints: (builder) => ({
<name>: builder.query<ResponseType, RequestType>({
query: (arg) => `/endpoint/${arg}`,
providesTags: ['<TagType>'],
}),
}),
});
export const { use<Name>Query } = <feature>Api;schema <name>
Create src/schemas/<name>.schema.ts:
import { z } from 'zod';
export const <name>Schema = z.object({
id: z.string().uuid(),
// add fields
createdAt: z.string().datetime(),
updatedAt: z.string().datetime(),
});
export type <Name> = z.infer<typeof <name>Schema>;
export const create<Name>Schema = <name>Schema.omit({
id: true,
createdAt: true,
updatedAt: true,
});
export type Create<Name> = z.infer<typeof create<Name>Schema>;Step 4: Post-generation checklist
After generating any code, output this checklist with only the items relevant to what was generated:
Generated: <list of files created/modified>
Checklist:
[ ] Run `yarn lint:fix` to auto-format generated files
[ ] Add reducer to src/store/reducers.ts (if new slice)
[ ] Add tag type to src/services/api/api.ts tagTypes (if new entity)
[ ] Register route in src/navigation/routes.ts (if new screen)
[ ] Add route type to src/navigation/routes.types.ts (if new screen)
[ ] Add translation keys to src/locales/en.json (if new screen/component)
[ ] Add translation keys to src/locales/fr.json
[ ] Write tests in __tests__/ next to the new fileHard constraints (never violate)
- No
StyleSheet.create()— Restyle only - No inline styles:
style={{ ... }}— use Restyle Box props - No hardcoded values:
padding={16},backgroundColor="#fff"— use theme tokens - No
AsyncStorage— use MMKV or SecureStore - No
useSelector/useDispatch— useuseAppSelector/useAppDispatch - No
FlatList— useFlashListwithestimatedItemSize - No cross-feature imports — features only import from
#services/,#ui/,#utils/,#store/ - No
anyin TypeScript — explicit types always - No hardcoded strings in JSX —
t('key')always - No missing barrel exports — every generated file gets exported from the feature's
index.ts
Does it work?
Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.
No reviews yet
People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.
- It worked
- Partly
- It didn't
Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.
Your trail
Files you open will collect here, so you can find them again.
Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.
Now do this for your own.
Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.

