Advanced App Development with AI

Construct complex layouts using Row, Column, Stack, Expanded, and Flexible.

Apply Flutter's box constraints model to debug common layout issues.

Define a global app theme with Material 3 ThemeData, including custom fonts and color schemes.

Build responsive layouts that adapt to different screen sizes using MediaQuery and LayoutBuilder.

Implement implicit animations using widgets like AnimatedContainer and AnimatedOpacity for smooth UI transitions.

Create explicit animations using AnimationController, Tweens, and AnimatedBuilder for fine-grained control.

Create platform-adaptive UI elements by conditionally rendering Cupertino widgets for iOS.

Project: Build a responsive multi-section landing screen with theming, dark mode, and an animated call-to-action button.

Implement imperative navigation between screens using Navigator 2.0 (push/pop).

Set up type-safe, declarative routing and deep linking using the go_router package.

Pass and return data between screens in a structured way.

Build nested navigation patterns, such as a tabbed interface with a persistent BottomNavigationBar.

Create shared element transitions between screens for a polished user experience using the Hero widget.

Build robust forms with validation, focus management, and input formatting using Form and TextFormField widgets.

Project: Build a 3-screen app with tabbed navigation, deep linking into a detail screen, and a validated sign-up form.

Differentiate between ephemeral state and app state and know when to use `setState`.

Explain the limitations of `setState` and the need for a centralized state management solution.

Describe the core principles of Riverpod: providers, consumers, and dependency injection.

Use basic Riverpod providers (Provider, StateProvider, FutureProvider) to share state across the widget tree.

Manage complex state logic using Riverpod's Notifier and AsyncNotifier.

Structure an app by separating UI from business logic using Riverpod providers.

Project: Build a multi-step survey app where each step's state is managed by Riverpod, and the final result is aggregated from different providers.

Describe the purpose and structure of Clean Architecture in Flutter (Presentation, Domain, Data layers).

Implement the Repository pattern to abstract data sources from the rest of the application.

Define Use Cases (Interactors) to encapsulate specific business logic within the Domain layer.

Model state and logic using the BLoC pattern, differentiating between a simple Cubit and a full Bloc with events.

Compare Riverpod and BLoC, and select the appropriate pattern for a given scenario based on project needs.

Project: Refactor the survey app into a Clean Architecture structure using a Repository, Use Cases, and either Riverpod or BLoC for state management.

Make REST API calls using the `dio` package, including configuring interceptors for logging and authentication.

Serialize and deserialize complex JSON using model classes with `json_serializable` and `freezed`.

Implement robust error handling for network requests and configure timeouts.

Persist simple key-value data locally using the `shared_preferences` package.

Store structured local data using the Drift (Moor) library as a type-safe ORM over SQLite.

Project: Build a news reader app that fetches articles from a REST API and caches them locally with Drift for offline reading.

Request and handle runtime permissions for device features on both Android and iOS.

Capture or select an image from the device using the `image_picker` plugin.

Access the device's current geolocation using the `geolocator` plugin.

Use the retrieved location data to center a map view and place markers.

Integrate an interactive Google Map into a Flutter screen using the `google_maps_flutter` plugin.

Project: Build a 'photo journal' app that lets users add entries by taking a photo and automatically tagging it with their current location on a map.

Configure Firebase in a Flutter project for Android and iOS using the FlutterFire CLI.

Implement user sign-up and sign-in with email/password and social providers (Google/Apple) using Firebase Auth.

Perform CRUD operations on documents in Cloud Firestore.

Query, filter, and listen for real-time data changes in Firestore using Streams.

Upload and retrieve user files (e.g., images) using Firebase Storage.

Deploy and call a simple Cloud Function to handle server-side logic.

Project: Build a real-time multi-user 'to-do' app with social authentication, Firestore data sync, and image attachments for tasks.

Explain LLM API fundamentals: tokens, prompts, models, and context windows.

Call an LLM provider's chat completion API (e.g., OpenAI, Gemini) from Flutter.

Secure API keys by proxying requests through a Cloud Function.

Stream LLM responses token-by-token into a Flutter UI for a real-time effect.

Maintain a multi-turn conversation history and manage the context window to avoid errors.

Use system prompts and few-shot examples to guide LLM behavior for specific tasks.

Project: Build a simple 'expert chat' app where the user can select an expert persona (e.g., 'Chef', 'Historian') and have a conversation, with streaming responses.

Implement a responsive chat UI with automatic scrolling, message list, and keyboard handling.

Integrate the chat UI with streaming LLM responses, managing loading, error, and success states end-to-end.

Build a text summarization feature by creating a dedicated UI, prompt strategy, and state-managed LLM integration.

Integrate voice input using a speech-to-text plugin, including handling necessary permissions.

Add voice output to the app using a text-to-speech plugin to read responses aloud.

Project: Build a 'voice assistant' screen that allows users to ask questions via voice, see the streaming text response, and hear it spoken back.

Explain the concept of text embeddings and their use in measuring semantic similarity.

Generate text embeddings for chunks of text using an embedding model API.

Describe the role of a vector store (database) in efficiently storing and querying embeddings.

Implement a basic semantic search feature over a small knowledge base.

Explain and implement the Retrieval-Augmented Generation (RAG) pattern: retrieve relevant context and inject it into an LLM prompt.

Project: Build an 'AI Study Buddy' that allows a user to ask questions about a specific document (e.g., a chapter of a book) using RAG to provide contextually accurate answers.

Write unit tests for Dart business logic (Use Cases, Notifiers) and widget tests for UI components.

Write an integration test for a critical user flow, such as authentication or core feature interaction.

Profile app performance using Flutter DevTools to identify and fix sources of 'jank' (UI stutter).

Improve app accessibility using Semantics widgets and supporting dynamic type.

Configure app branding (icons, splash screens) and build signed release bundles for Android (AAB) and iOS (IPA).

Create a GitHub Actions workflow that runs tests on push and builds a signed Android release artifact.

Publish an app to the Google Play Console's internal testing track and distribute an iOS build via TestFlight.

Project: Add a full test suite (unit, widget, integration) and a CI/CD pipeline to a previous project, then deploy it to internal testing tracks.