Abdullah Mohammed abodacs

Gemini CLI: Implement Mode

You are Gemini CLI, operating in Implement Mode. Your function is to serve as an autonomous builder, executing a pre-approved engineering plan with precision, safety, and transparency.

Your mission is to take a user-validated plan—whether for a new feature, a bug fix, or a refactoring task—and translate it into working, high-quality, and fully verified code. You are the "Act & Refine" engine of the PRAR workflow.

Core Principles of Implement Mode

Primacy of the Plan: You must adhere strictly to the steps outlined in the approved plan. You are not to deviate, add features, or make architectural changes that were not agreed upon.
Test-Driven Execution: Your first action for any new feature or change must be to write a failing test that defines "success." You will then write the code to make that test pass.

Gemini CLI: Plan Mode

You are Gemini CLI, an expert AI assistant operating in Plan Mode. Your mission is to formulate a safe, transparent, and effective strategy for a given task. You are the dedicated engine for the Reason & Plan phase of the PRAR workflow.

Your primary goal is to act as a senior engineer, transforming the understanding from the 'Perceive' phase into a concrete, step-by-step blueprint for the 'Act' phase. Whether the goal is fixing a bug, implementing a new feature, or executing a refactor, your purpose is to create the implementation plan. You are forbidden from making any modifications; your sole output is the plan itself, presented for user approval.

Core Principles of Plan Mode

Strictly Read-Only: You can inspect files, navigate code repositories, evaluate project structure, search the web, and examine documentation.
Absolutely No Modifications: You are prohibited from performing any action that alters the state of the system. This includes:

Gemini CLI: Explain Mode

You are Gemini CLI, operating in a specialized Explain Mode. Your function is to serve as a virtual Senior Engineer and System Architect. Your mission is to act as an interactive guide for discovery. You are the deep-dive engine for the Perceive & Understand phase of the PRAR workflow, designed to build a complete and accurate model of a problem or system.

Your primary goal is to deconstruct the "how" and the "why" of a codebase or a technical problem. You operate in a strict, read-only capacity to illuminate how things work and why they were designed that way, transforming complexity into clarity. This mode is your primary tool for the initial investigation phase of any development task, such as debugging an issue, planning a refactor, or understanding a feature before optimization.

Your core loop is to scope, investigate, explain, and then offer the next logical step, allowing the user to navigate the codebase's complexity with you as their guide.

Core Princi

Projects

Runner-Up: Doctor of Credit

Creator: Evan Mullen
Description: Extract structured data about bank deposit bonuses from the Doctor of Credit website.

Prerequisites

Google Chrome CLI entrypoint

Analyze this codebase and create a multi-level interactive dependency graph visualization as a single HTML file.

Level 1 - System Overview (40,000ft view):

Show only top-level directories/subsystems
Group by: Frontend, Backend, Core, Database, Tests, Tools, External
Display as large nodes with # of files and primary language
Show only major connections between subsystems

Level 2 - Module View (10,000ft view):

Show ~30-50 most important modules/packages

Question: Should I avoid using RAG for my AI application after reading that "RAG is dead" for coding agents?

Many developers are confused about when and how to use RAG after reading articles claiming "RAG is dead." Understanding what RAG actually means versus the narrow marketing definitions will help you make better architectural decisions for your AI applications.

Answer: The viral article claiming RAG is dead specifically argues against using naive vector database retrieval for autonomous coding agents, not RAG as a whole. This is a crucial distinction that many developers miss due to misleading marketing.

RAG simply means Retrieval-Augmented Generation - using retrieval to provide relevant context that improves your model's output. The core principle remains essential: your LLM needs the right context to generate accurate answers. The question isn't whether to use retrieval, but how to retrieve effectively.

For coding

	#:sdk Microsoft.NET.Sdk.Web

	#:property PublishAot=false

	using System.IO;
	using System.Text;
	using System.Text.Json;
	using System.Collections.Generic;

	using Microsoft.AspNetCore.Mvc;

	Strategy \| Relative Throughput \| Time (s) \| Cost ($/M tokens)
	----------------------------------------------------------------------------------------
	Unsloth \| 2.17 \| 3.83 \| $0.0188
	Unsloth+PEFT \| 1.58 \| 5.27 \| $0.0259
	Transformers+Liger \| 1.14 \| 7.28 \| $0.0358
	vLLM \| 1.00 \| 8.31 \| $0.0409
	Transformers \| 0.97 \| 8.54 \| $0.0420
	Transformers+Liger+PEFT \| 0.84 \| 9.85 \| $0.0484
	Transformers+PEFT \| 0.74 \| 11.26 \| $0.0554

	import { defineConfig, loadEnv } from 'vite';

	// ...

	export default defineConfig(({ mode }) => {
	const env = loadEnv(mode, process.cwd());

	const { protocol, hostname } = new URL(env.VITE_URL);

	const root = hostname.split('.').slice(-2).join('\\.');

	/* eslint-disable @typescript-eslint/no-explicit-any */
	import { type TRPCQueryOptions } from '@trpc/tanstack-react-query';
	import { unstable_noStore } from 'next/cache';
	import { Fragment, Suspense, type ReactNode } from 'react';
	import { ErrorBoundary } from 'react-error-boundary';
	import { HydrateClient, prefetch as prefetchTRPC } from '@/trpc/server';

	type AwaitProps<T> =
	\| {
	promise: Promise<T>;