AI Experience — Professional Use Across OpenAI, Claude, Gemini, Coding Agents, APIs & Local Models
Experience Area: Professional AI Use, Coding Agents, AI APIs, Local Models & AI-Assisted Development
Platforms & Tools: ChatGPT Plus, OpenAI API, Codex App, Codex CLI, Claude App, Claude Code, Gemini Pro, Gemini API, Gemini CLI, Google AI Studio, Antigravity, Cline, Cursor, OpenCode, OpenRouter, Groq, Cerebras, Mistral, LM Studio, Ollama, ComfyUI
How I Actually Use AI
I do not use one AI product and I do not keep replacing one model with the next new model.
I use several AI systems in parallel.
The decision depends on the job:
- How much reasoning does it need?
- Does the model need direct access to a repository?
- Is the task expensive to run?
- How much context does it need?
- Does it need terminal access?
- Can a cheaper/free model safely handle it?
- Does the result need deterministic validation?
- Is this planning, implementation, research, structured output, or rendering?
That is the real experience I have built over years of professional AI use.
OpenAI Has Been My Main Professional AI Stack
I have used ChatGPT professionally since the early ChatGPT era and have maintained paid ChatGPT access for years.
I have worked through OpenAI’s paid model generations as they became available and continue using the current generation, including GPT-5.6 Sol.
OpenAI has remained my primary choice for the work where I care most about reasoning quality, architecture, planning, research synthesis, specifications and difficult decision-making.
I also use the OpenAI API inside real automation and software systems rather than only through the ChatGPT interface.
That includes work involving:
- Structured JSON generation
- Content systems
- SEO workflows
- Advertising automation
- Classification and decision steps
- API-driven AI inside n8n
- Web application AI features
- Validation and repair loops
Codex Is My Strongest Direct Coding Execution Lane
When the job moves from planning into repository execution, I use Codex App and Codex CLI.
I have used Codex directly from development environments and from PowerShell/automation workflows.
For me, Codex is not the same thing as ChatGPT.
The roles are different.
ChatGPT: understand the problem, plan, specify, review and make higher-level decisions.
Codex: inspect the repository, edit real files, run commands, implement a bounded change and verify the result.
I have also learned that Codex is powerful enough that it should not receive vague instructions.
My preferred pattern is:
clear requirement → bounded task → repository execution → targeted verification → stop.
I do not want an agent redesigning an entire application simply because it found another way to implement something.
I Have Used OpenAI Models at Different Cost/Capability Levels
I do not automatically send every job to the most expensive model.
For difficult architecture, release work, debugging or high-risk implementation, I prefer the strongest available model.
For deterministic batches, small rewrites, mechanical edits or clearly specified implementation, a cheaper model can be enough.
This is important when working professionally because model quality matters, but so does usage efficiency.
The goal is not:
“Always use the biggest model.”
The goal is:
“Use enough intelligence for the risk of the task.”
Claude — Good Capability, But the Paid Usage Model Has Not Fit My Workload
I have tested and used both Claude App / Claude Pro and Claude Code.
I understand why developers like Claude, and I have found it useful in technical work.
But for my own workload, Claude Pro has been extremely usage-limited compared with the amount of work I want to do.
That makes it difficult for me to treat Claude as my primary professional environment.
So I do not write a portfolio claim such as:
“Claude replaced ChatGPT for me.”
It did not.
I use and evaluate Claude where it makes sense, but OpenAI remains much more practical for my main professional workload.
Gemini — I Use Several Google AI Lanes for Different Reasons
My Gemini experience is also not one product.
I have used:
- Gemini Pro
- Gemini through the consumer application
- Gemini API / free API access
- Gemini CLI
- Google AI Studio
Each has had different advantages.
Gemini models can be useful for large-context inspection, inexpensive API work, experimentation and some implementation tasks.
The free API lane has also been useful when a task does not justify paying OpenAI API prices.
But for my own higher-level work, I do not consider Gemini Pro close to ChatGPT as my primary reasoning and planning environment.
I still use Gemini because “not my best overall model” does not mean “not useful.”
Gemini CLI Was Useful as a Development Agent
I also used Gemini CLI for repository and command-line work.
It gave me another direct-execution option outside the OpenAI ecosystem and was useful enough that I incorporated it into real development experiments.
My experience also taught me not to build a permanent workflow around one vendor-specific CLI.
Tool support changes.
Providers change products, models and limits.
So the durable skill is not memorizing one CLI.
It is understanding how to move the same bounded development task between capable agents.
Antigravity Is Another Execution Environment — Not the Project Brain
I have also used Antigravity in real web-development workflows.
I treat it as an executor, not as the authority that decides what the project should become.
A useful Antigravity task is tightly scoped:
edit this named deliverable → follow these requirements → do not advance the next phase → stop.
This protects the project from agent-driven scope drift.
Cline Gives Me a Controlled Multi-Provider Executor
I use Cline differently from native Codex.
Cline is useful because I can connect different providers/models to the same development workflow.
I have used it with models from ecosystems such as Gemini, Mistral, DeepSeek, Poolside, StepFun, OpenRouter and other available providers.
That makes it useful for comparing models and assigning cheaper models to small, bounded tasks.
But I do not treat a cheap/free model inside Cline as equivalent to native Codex on high-risk repository work.
For important acceptance or authoritative implementation, model quality still matters.
OpenCode Is Useful for Multi-Provider Experiments
I have also worked with OpenCode through its GUI.
I used it with connected providers such as GitHub Copilot, Groq and OpenRouter and tested different available/free model options.
This is another example of how I work:
I am interested in separating the agent interface from the model provider.
The same development environment can become much more flexible when the underlying model can be changed.
Cursor and Other IDE-Based Agents
I have also used tools such as Cursor and IDE/agent integrations where AI works directly beside the codebase.
I use these when interactive editing and quick inspection are more useful than a long autonomous run.
CLI, IDE and app-based agents all have a place.
I do not treat one interface as universally superior.
REST/API Models Are a Separate Part of My AI Experience
A large part of my experience is not tied to any AI chat application.
I regularly work with models as APIs.
I have tested and used AI through providers and routing platforms including:
- OpenAI API
- Gemini API
- OpenRouter
- Groq
- Cerebras
- Mistral
- Other models exposed through multi-provider development tools
I have compared models from families such as:
- GPT
- Gemini
- Qwen
- DeepSeek
- Mistral
- GLM
- GPT-OSS
- Nemotron
- Poolside
- StepFun
The practical question is rarely:
“Which benchmark has the highest score?”
I care more about:
Does it follow the contract? Does it understand the task? Does it return reliable structured output? How much does it cost? How fast is it? What happens when it fails?
Local AI Is Another Parallel Lane
I also run models locally using LM Studio and Ollama.
I use local AI when I want to experiment with open models, reduce API dependence, test low-cost execution or connect an application to a local inference endpoint.
LM Studio has been particularly useful because I can expose a local OpenAI-compatible API and connect it to software or n8n.
I have tested local models in real workflows rather than only chatting with them manually.
Local Models Have Also Taught Me Their Limits
Running a model locally does not make it equivalent to a frontier cloud model.
I have seen local/smaller models:
- Return malformed JSON
- Add reasoning before structured output
- Miss important instructions
- Produce plausible but unsupported content
- Perform well on a narrow task and poorly on a slightly harder one
So I use local AI selectively.
If a small model can safely complete a bounded task, good.
If the task requires strong judgment, I do not force a local model into it just to save API cost.
ComfyUI Is My Local AI Image Infrastructure
I use ComfyUI differently from language models.
It is a programmable image-generation engine.
I have connected ComfyUI to n8n workflows so another automation can prepare a scene, construct the generation payload, submit it, wait for rendering, inspect the result and retrieve the generated image.
This has allowed me to work with parameters such as:
- Prompt / negative prompt
- Dimensions
- Seed
- Steps
- CFG
- Denoise
- Reference-image strength
- Upscaling
- Models / LoRAs
For me, ComfyUI is not only an image UI.
It can operate as an image-rendering service inside a larger automation.
I Combine These Systems in Parallel
A real project may use several of them at the same time.
For example:
ChatGPT may define the architecture and acceptance criteria.
Codex may implement the important repository change.
Cline or another cheaper model may perform a small mechanical batch.
Gemini may inspect a large context or handle a low-cost API task.
LM Studio may run a bounded local inference step.
ComfyUI may render the image.
n8n may orchestrate all of them.
These are parallel capabilities.
They are not a timeline where one replaced the previous one.
My Experience Is Mostly About Routing and Control
After years of professional AI use, I care less about hype around a single model.
I care about choosing the right lane.
High-risk reasoning: use the strongest trusted model.
Repository execution: use a capable coding agent with bounded instructions.
Mechanical work: consider cheaper/free models.
Large-context inspection: route to a model that handles it efficiently.
Local/private/low-cost inference: use LM Studio or Ollama when the model is good enough.
Image rendering: use ComfyUI.
Repeatable machine workflow: call the models through APIs instead of depending on a chat window.
The Biggest Lesson
I have used enough AI products to know that there is no permanent “best AI for everything.”
Models change.
Usage limits change.
Pricing changes.
Agent products change.
APIs fail.
A model that is excellent at one task can be disappointing at another.
The durable skill is:
knowing how to combine models, agents, APIs, local runtimes, deterministic code and human judgment into a workflow that still works when one component changes.
Platforms & Skills Demonstrated
ChatGPT Plus · OpenAI API · GPT-5.6 Sol · Codex App · Codex CLI · Claude App · Claude Code · Gemini Pro · Gemini API · Gemini CLI · Google AI Studio · Antigravity · Cline · Cursor · OpenCode · OpenRouter · Groq · Cerebras · Mistral · LM Studio · Ollama · ComfyUI · Local LLMs · AI Coding Agents · AI APIs · Multi-Provider Routing · Structured Outputs · JSON Validation · Prompt Engineering · AI Cost Control · Model Evaluation · Local Inference · AI Image Automation · n8n AI Integration · Human-in-the-Loop Systems