Codetutor

In this video, you’ll see how Android development workflows are changing with agentic development, and how Android CLI and Android skills can help agents work faster and with better proof.

The walkthrough compares the older Android workflow, where developers directly wrote code in Android Studio, with the newer flow where a coding agent writes and runs code through prompts. The key shift is that Android Studio is no longer the main surface for development. Instead, it becomes more of a review surface, while Android CLI gives agents direct, practical access to the Android toolchain.

This video covers:
how Android development used to work vs how it works now
what Android CLI is and why it matters
how Android skills guide the agent while Android CLI handles execution
examples of Android CLI commands like describe, help, run, screen capture, and preview rendering
how agents can inspect builds, rendering, screenshots, and runtime behavior
why proof of a fix matters more than just claiming success
how Android CLI helps agents show evidence through screenshots, previews, and layout inspection
a live example of breaking a Jetpack Compose UI, asking an agent to fix it, and comparing the difference with and without Android CLI and Android skills

A big theme in this video is that the real improvement is not just a smarter agent, but a workflow that can verify and prove what changed. Instead of only editing code and reporting success, the agent can now build, render, inspect, capture evidence, and show whether the UI actually matches the intended result.

If you’re exploring AI-assisted Android development, this is a practical look at how Android CLI and Android skills fit into modern Android workflows.

#Android #AndroidDevelopment #AndroidCLI #JetpackCompose #AndroidStudio #AI #AIAgents #AgenticDevelopment #MobileDevelopment #Kotlin #Gradle #ADB #Emulator #SoftwareDevelopment #DeveloperTools

00:00:00 - Android CLI and the Shift to Agentic Android Development
00:03:08 - Android CLI Commands and Project Inspection Demo
00:06:06 - Fixing a Broken UI Without Android CLI
00:09:09 - Installing Android Skills and Using Android CLI for Evidence
00:12:14 - Proof-Driven Android Workflows with Screenshots and Layout Inspection
00:14:00 - Final Takeaways on Android CLI and Android Skills

Follow me on X: https://x.com/anilvdeshpande
Official WebSite: https://codetutorhub.dev/

Android Skills + CLI: The New Android Workflow devs should master

If you're using AI for coding and noticing heavy token usage, this video walks through a practical way to reduce that cost with Graphify.

Graphify is an open-source framework that maps your codebase into a graph structure so LLMs and coding agents can understand files, folders, function calls, and relationships much more efficiently. Instead of relying on manually maintained README folder trees, you can let Graphify generate a navigable visual map of your repo and keep it refreshed automatically.

In this video, I show:
how Graphify helps reduce token waste during code navigation
why manual repo structure documentation often becomes outdated
how Graphify builds relationships between files, functions, and modules
how to identify dead code and ambiguous connections
how communities are created and why they matter
how to set up Graphify in a fresh repository
how to audit duplicate community names and fix them
how to enable existing agents and skills to use Graphify-first workflows
how to improve graph quality by reviewing inferred or dashed-line relationships
how Graphify starts getting used in real repo queries after setup

I also demonstrate a fresh setup in a real codebase using Codex, including planning changes before applying them, refreshing the graph output, wiring agents and skills to Graphify, and verifying that future queries actually use the Graphify context.

If you work with large repositories, multiple AI coding tools, or cross-platform agent workflows, this approach can make code understanding more structured and potentially reduce token consumption significantly after the initial setup.

If you’ve tried Graphify or similar code-mapping tools, share your experience and what has worked best for you.

#Graphify #AIProgramming #LLM #CodebaseMapping #DeveloperTools #AICoding #Codex #GitHubCopilot #Claude #OpenSource #SoftwareDevelopment #CodeNavigation #AgenticWorkflow #TokenOptimization #ProgrammingTools

00:00:00 - Why AI Coding Burns Too Many Tokens
00:01:09 - What Graphify Is and How It Maps Your Codebase
00:06:13 - Setting Up Graphify in a New Repository
00:09:35 - Fixing Duplicate Nodes and Community Names
00:13:00 - Enabling Graphify for Agents and Skills
00:17:14 - Improving Dashed Links and Graph Accuracy
00:19:07 - Testing Graphify With Real Workflow Queries
00:20:38 - Final Thoughts on Token Savings With Graphify

Follow me on X: https://x.com/anilvdeshpande
Official WebSite: https://codetutorhub.dev/

Map Your Codebase with Graphify & Stop Wasting Tokens | Setup & Configuration

Loops are everywhere in AI engineering and agentic development right now, but should you actually use them?

In this video, I break down what loops really are, how they work, why they can be powerful, and where they become unnecessarily expensive. We look at the basic loop structure, the role of stop conditions, and why repeating model calls can quickly increase both token cost and system complexity.

I also cover the major loop patterns you are likely to encounter in agentic workflows:
ReAct
Plan and Execute
Reflection
Reflexion

The video also explains the practical tradeoffs behind looping:
when loops help
when they waste tokens
how reliability drops as more steps are added
why verification matters
why failed iterations still cost money
and why not every loop should be treated as an agent

A key part of the discussion is the difference between a workflow and an agent. If your code controls whether the loop continues, it is a workflow. If the model decides whether to continue or stop, that is what makes it an agent. That distinction changes how you should design and trust these systems.

If you are building AI agents, coding workflows, or evaluation loops, this video will help you decide when loops are justified and when a single good model call is the better engineering choice.

Let me know which loop patterns you use most often and where you avoid loops entirely.

#AIEngineering #AgenticAI #AIAgents #LLM #PromptEngineering #ReAct #Reflection #Reflexion #PlanAndExecute #AIWorkflow #MachineLearning #SoftwareEngineering #AIDevelopment #LLMOps #GenerativeAI

00:00 - AI Loops Debate Explained
00:52 - Why Unnecessary Loops Waste Tokens
01:53 - How Loops Work and Why Stop Conditions Matter
03:43 - The 4 Main Loop Types: ReAct, Plan and Execute, Reflection, Reflexion
06:58 - The Real Cost of Looping and Reliability Tradeoffs
09:30 - Verification Loops and Why Self-Checking Fails
10:29 - Workflow vs Agent: Who Owns the Control Flow?
11:59 - When to Use Loops in AI Engineering

Follow me on X: https://x.com/anilvdeshpande
Official WebSite: https://codetutorhub.dev/

Are AI Loops Worth It? When to Use Them & When to Avoid them

In this final part of the Android CI/CD series, we look at how to actually deliver the APK generated by GitHub Actions to testers in a reliable way.

A successful build is not the same as a successful delivery. Even if GitHub Actions creates the APK, testers may still not be able to access or install it easily. This video explains the gap between build success and tester delivery, and shows how Firebase App Distribution helps close that gap.

You will learn:
how developer access to GitHub Actions differs from tester access
what reliable APK distribution really needs
how to choose the right distribution option based on audience and release stage
why Firebase App Distribution is a good fit for invited external testers
how Firebase, Google Cloud, GitHub, and local signing setup work together
which settings are secrets and which are not
why signing credentials and distribution credentials are different
how Google Cloud IAM permissions affect Firebase uploads
why the service account needs the Firebase App Distribution admin role
how to store Firebase app ID, service account JSON, and keystore values in GitHub
how to handle APK selection correctly when multiple build variants exist
how the workflow installs Firebase CLI and uploads the APK
what the tester invitation and installation flow looks like
how to confirm that a release actually reached the tester

This video also wraps up the full Android CI/CD series by connecting all the pieces together, from validating code changes to building and signing the APK and finally distributing it to invited testers.

If you are setting up Android CI/CD and want a practical tester distribution flow using GitHub Actions and Firebase, this video walks through the complete process.

#Android #AndroidDevelopment #CICD #AndroidCICD #GitHubActions #Firebase #FirebaseAppDistribution #GoogleCloud #DevOps #MobileDevOps #APKDistribution #QATesting #ContinuousIntegration #ContinuousDelivery #AndroidTesting

00:00:00 - Why Build Success Is Not Enough for APK Delivery
00:02:31 - What Reliable APK Distribution Needs
00:03:47 - Choosing Firebase App Distribution for Testers
00:06:18 - Firebase, Google Cloud, and GitHub Secrets Setup
00:10:09 - Correct Setup Order for Firebase App Distribution
00:11:53 - Signing vs Distribution Credentials Explained
00:14:43 - Handling Build Variants and GitHub Actions Workflow
00:18:10 - Tester Invitation Flow and Android CI/CD Series Wrap-Up

Follow me on X: https://x.com/anilvdeshpande
Official WebSite: https://codetutorhub.dev/

Automate APK Delivery: Firebase + GitHub Actions | Android CICD Finale

Trying to make sense of agentic development terms like agent, sub-agent, tool, skill, hook, plug-in, and MCP server? This video builds a simple mental model so you can understand what each one does, where it fits, and how they work together in a real repository setup.

In this video, you’ll learn:
what an agent is and how it acts as the decision-maker
what tools are and how agents use them to perform actions
how skills guide agent behavior with reusable instructions
when to use a sub-agent for specialized delegated work
how hooks automatically intercept, validate, log, and enforce rules
what an MCP server is and how it exposes external systems to agents
how plug-ins package the full AI setup for team-wide reuse

The video also walks through a practical repository structure showing how agents, skills, hooks, and MCP configuration can be organized in a real project. It explains how these ideas apply across platforms like Copilot, Claude, and Codex, so you can focus on the fundamentals instead of getting stuck on tool-specific naming differences.

If you’re building AI workflows for code generation, code review, planning, or automation, this will help you choose the right abstraction for the right job and avoid confusing similar concepts.

#AgenticDevelopment #AIEngineering #AIAgents #MCP #ModelContextProtocol #AIAutomation #DeveloperTools #SoftwareArchitecture #CodeAutomation #GitHubCopilot #OpenAICodex #ClaudeAI #AIWorkflow #LLMTools #AISetup

00:00:00 - Agentic Development Overview
00:01:44 - What Agents and Tools Actually Do
00:03:58 - Skills as Reusable Playbooks
00:05:49 - Sub-Agents for Specialized Tasks
00:08:02 - Hooks for Validation, Logging, and Safety
00:10:00 - MCP Servers and External Tool Integrations
00:13:29 - Real Repository Setup with Agents and Skills
00:16:51 - Plugins, Packaging, and the Final Mental Model

Follow me on X: https://x.com/anilvdeshpande
Official WebSite: https://codetutorhub.dev/

Stop Overcomplicating AI Agents: Understanding Hooks, Skills, and MCP Without the Confusion

In this video, I break down what Forward Deployment Engineers, or FDEs, actually do and why this role is suddenly showing up across AI companies like OpenAI and Anthropic.

The core idea is simple: many companies have bought expensive AI licenses expecting major productivity gains, but very few are truly ready to use AI effectively at scale. They may have access to powerful models, but their internal data, workflows, systems, and processes are too fragmented to make those models useful in real production environments.

That is where FDEs come in.

These engineers work closely with enterprise customers to help integrate LLMs into real business workflows. That can include connecting scattered internal data, building retrieval systems, setting up MCP servers, creating prompts, designing production-ready AI workflows, and making organizations more AI ready overall.

In the video, I cover:
what the FDE role means in practice
where the role comes from historically
why AI companies are hiring so many FDEs now
why most enterprises are struggling to get real ROI from AI
how FDEs help move AI projects from pilot stage to production
why this role looks a lot like consulting in a new form
the risks of vendor lock-in when AI providers build deeply coupled internal systems
the governance, compliance, and data exposure concerns enterprises need to think through
how traditional consulting firms may respond with model-agnostic alternatives

The bigger point is that FDE is not really a completely new category of work. It is software engineering and consulting focused on deploying AI systems inside enterprises. The demand is rising because companies are realizing that buying an LLM is not enough. They also need the surrounding infrastructure, data access, and workflow integration to make AI useful.

If you are trying to understand where AI jobs are heading, how enterprise AI adoption is actually working, or what new roles are emerging around LLM deployment, this discussion will give you a practical view of the shift.

#FDE #ForwardDeploymentEngineer #AIEngineering #LLM #OpenAI #Anthropic #EnterpriseAI #AIDeployment #SoftwareEngineering #AIJobs #RAG #MCP #Consulting #AIAutomation #Productivity #GenerativeAI

00:00:00 - What Is a Forward Deployment Engineer?
00:01:06 - Palantir Origins and the FDE Role
00:02:42 - How FDEs Help Deploy OpenAI and Anthropic
00:03:24 - Why Companies Need FDEs for AI Readiness
00:07:53 - What FDEs Actually Build Inside Enterprises
00:08:53 - Is FDE Just AI Consulting in Disguise?
00:11:14 - Vendor Lock-In Risks With FDEs
00:14:28 - Data Exposure, Field Intelligence, and Final Takeaways

Follow me on X: https://x.com/anilvdeshpande
Official WebSite: https://codetutorhub.dev/

The New AI Job: Why OpenAI & Anthropic are hiring FDEs

In this video, we break down Android APK signing in a simple and practical way.

If you have worked with Android builds but still feel unclear about what signing actually means, this episode explains the full mental model behind it. The focus is on understanding the difference between debug signing and release signing, why signing is required, and how keystore-related values fit together in local builds and CI/CD pipelines.

Topics covered:
debug APK signing and how Android signs debug builds automatically
why debug builds can be installed quickly on emulators and test devices
the role of release signing in app identity and update continuity
why losing your signing key means losing the ability to update your app
what a keystore file is and what it contains
the difference between store password and key password
what key alias means
how the signing flow works step by step
how signing appears in Gradle signing configs
how local.properties is used for local signing
how Android Studio generates signed APKs through the UI
how the same signing process is handled in GitHub Actions CI/CD using protected secrets
why production signing secrets should only be available to release workflows

This video is useful for Android developers who want to better understand APK and AAB signing before setting up release automation or publishing apps.

#Android #AndroidDevelopment #APKSigning #AppSigning #Keystore #JKS #AAB #Gradle #AGP #CICD #GitHubActions #MobileDevelopment #PlayStore #ReleaseBuild #DebugBuild

00:00 - Android APK Signing Overview
01:58 - How Debug APK Signing Works
05:09 - Release Signing Config Explained
06:16 - Keystore, Alias, Password, and Private Key
08:40 - Signing APKs Locally and in CI/CD
10:30 - Debug vs Release Build Signing Differences

Follow me on X: https://x.com/anilvdeshpande
Official WebSite: https://codetutorhub.dev/

Gitghub Link to demo code : https://github.com/AnilDeshpande/VarientDemoApplication/tree/live-coding

What Is Android APK Signing? Keystore, Key Alias, Passwords, and Release Flow | Android CICD - 20

In this video, we move beyond a basic Android CI/CD demo and look at how to structure CI pipelines the way real Android teams actually use them.

The focus here is on separating responsibilities instead of using one script for everything. You will see why a pull request check should only validate code quality and build health, while a main branch build can generate artifacts for testing, and a release pipeline should handle signing separately and only when triggered intentionally.

This video covers:
how PR checks should run lint, unit tests, and debug builds without signing or uploading artifacts
why generating signed builds during PR creation or merge does not make sense
how a main branch pipeline can verify merged code and upload APKs for testing
why release signing should live in a separate workflow
how manual workflow dispatch helps prevent accidental generation of signed production APKs
the practical difference between PR check, main build, and release build pipelines in Android CI/CD

If you are building Android apps with GitHub Actions or designing a cleaner CI/CD setup for your team, this video will help you understand how to split pipelines based on purpose and trigger conditions.

In the next video, the series moves deeper into Android app signing and what happens before final upload and release.

#Android #AndroidDevelopment #CICD #AndroidCICD #GitHubActions #DevOps #MobileDevOps #AndroidBuild #PullRequest #ContinuousIntegration #ContinuousDelivery #UnitTesting #Lint #APK #AppSigning #SoftwareEngineering

00:00:00 - Why One CI/CD Script Is Not Enough
00:03:28 - PR Check Pipeline for Lint, Tests, and Debug Builds
00:05:16 - Main Branch Build After Merge and Artifact Uploads
00:07:44 - Release Build for Signing and Production APKs
00:09:01 - Why Signed Builds Should Be Manually Triggered
00:09:54 - Video Wrap-Up and Next Steps

Follow me on X: https://x.com/anilvdeshpande
Official WebSite: https://codetutorhub.dev/
GitHub Link to demo: https://github.com/AnilDeshpande/VarientDemoApplication

Android CI/CD Pipelines You Actually Need for PR, Main, and Release | Android CICD - 19

In this video, we build a GitHub Actions CI/CD pipeline for a multi-build variant Android app.

You’ll see how to move from managing secrets in local.properties during local development to loading those same secrets securely in GitHub Actions at runtime. The workflow is designed to support multiple Android build variants, lets you choose the branch and variant when triggering the pipeline, classifies the selected variant into environment, tier, and build type, and then runs the correct Gradle task to generate the APK.

The video also covers:
Creating a workflow file under .github/workflows
Using workflow_dispatch inputs for branch and build variant selection
Supporting variants across QA, staging, and production
Extracting environment, flavor tier, and build type from the selected variant
Configuring Java in GitHub Actions
Loading common, environment-specific, and tier-specific secrets from GitHub secrets
Handling release signing secrets only for release builds
Building the APK with Gradle
Uploading the generated APK as a workflow artifact

You’ll also see a full demo of running the workflow for a QA free debug build and downloading the generated APK from the Actions run.

This is a practical continuation of the Android CI/CD series and helps you set up a cleaner and more scalable pipeline for apps with multiple build variants.

#Android #AndroidDevelopment #CICD #GitHubActions #AndroidCICD #Gradle #MobileDev #BuildAutomation #DevOps #APK #CI #CD #AndroidBuildVariants #GitHubSecrets

00:00:00 - Android CI/CD Setup for Multi-Build Variants
00:00:39 - Creating the GitHub Actions Workflow File
00:01:35 - Defining Workflow Inputs and Build Variant Options
00:03:03 - Parsing Environment, Tier, and Build Type
00:04:59 - Managing GitHub Secrets for Variant-Based Builds
00:06:56 - Running Gradle Build and Uploading the APK
00:08:15 - Triggering the Workflow and Verifying the Artifact
00:09:10 - CI/CD Best Practices and Final Takeaways

Follow me on X: https://x.com/anilvdeshpande
Official WebSite: https://codetutorhub.dev/

GitHub link to code: https://github.com/AnilDeshpande/VarientDemoApplication/tree/live-coding

GitHub Actions for Multi-Build Variants: Secrets Setup That Actually Works | Android CI/CD - Part 18

In this video, the Android CI/CD series moves from a simple GitHub Actions setup to a more realistic workflow for Android apps with multiple environments, product flavors, and build variants.

The video explains how to handle secrets for an app that has 12 possible build variants, and how to reduce that complexity by identifying only the builds that actually matter. Instead of managing dozens of secrets, the setup is simplified to a smaller and more practical set.

You’ll see how to:
set up and organize secrets in local.properties
separate environment-specific backend tokens for QA, staging, and production
manage flavor-specific SDK keys for free and paid tiers
define signing-related secrets for release builds
ignore sensitive files like local.properties, keystore, and JKS files from Git
generate a release keystore using keytool
load secrets inside build.gradle.kts
create helper functions to resolve secrets from either local files or CI/CD secrets
apply a fail-fast approach when required secrets are missing
configure proper signing for release builds instead of using the debug key
verify that the correct secrets are used for debug and release variants

The video also demonstrates how to test the setup locally before moving the same approach into the CI/CD pipeline.

If you’re building Android apps with multiple flavors and environments, this walkthrough shows a practical way to manage secrets and release signing without making your GitHub Actions workflow hard to maintain.

#Android #CICD #GitHubActions #AndroidDevelopment #Gradle #BuildVariants #ProductFlavors #MobileDev #DevOps #Kotlin #ReleaseSigning #SecretsManagement

00:00:00 - Android CI/CD Workflow for Multiple Build Variants
00:01:28 - Managing Secrets Across 12 Variants
00:03:01 - Defining Secrets in local.properties
00:04:30 - Ignoring Secret Files and Generating the JKS Keystore
00:06:11 - Loading Secrets in build.gradle.kts
00:08:29 - Configuring Release Signing and Build Variant Secrets
00:10:43 - Testing Debug and Release Builds
00:12:14 - Next Steps for CI/CD Pipeline Integration

Follow me on X: https://x.com/anilvdeshpande
Official WebSite: https://codetutorhub.dev/

GitHub link to code: https://github.com/AnilDeshpande/VarientDemoApplication/tree/live-coding

	Title	Published Date
	Android Skills + CLI: The New Android Workflow devs should master	Jul 7, 2026
	Map Your Codebase with Graphify & Stop Wasting Tokens \| Setup & Configuration	Jul 1, 2026
	Are AI Loops Worth It? When to Use Them & When to Avoid them	Jun 22, 2026
	Automate APK Delivery: Firebase + GitHub Actions \| Android CICD Finale	Jun 18, 2026
	Stop Overcomplicating AI Agents: Understanding Hooks, Skills, and MCP Without the Confusion	Jun 3, 2026
	The New AI Job: Why OpenAI & Anthropic are hiring FDEs	Jun 1, 2026
	What Is Android APK Signing? Keystore, Key Alias, Passwords, and Release Flow \| Android CICD - 20	May 27, 2026
	Android CI/CD Pipelines You Actually Need for PR, Main, and Release \| Android CICD - 19	May 19, 2026
	GitHub Actions for Multi-Build Variants: Secrets Setup That Actually Works \| Android CI/CD - Part 18	Apr 30, 2026
	Master Secret Management for Multi-Variant Android Builds \| Android CICD - 17	Apr 27, 2026