AI and automation practice with the engineering work made explicit
I have not launched AI products for paying customers. What I can show is local model work, FastAPI experiments, prompt documentation, and small automation workflows with clear limits.- Convo-AI: FastAPI backend, local model orchestration, and environment setup work.
- Automation: scripts and workflows that support personal projects and content pipelines.
- Documentation: prompt notes, disclosure of AI-assisted code, and manual review steps.
Clear scope, upfront
What I have
- Local AI experiments that run on my personal development machine.
- Documented prompts, edits, and limitations in READMEs.
- Basic automation scripts tied to personal projects.
What I am still working toward
- Production AI integrations or real-user telemetry pipelines.
- Enterprise guardrails, audits, or policy enforcement.
- Large-scale orchestration across teams and systems.
What I’m doing next
- Better evaluation workflows for outputs and hallucinations.
- Richer prompt orchestration with queues + storage.
- Security and privacy reviews before public releases.
Current focus
Local-first experiments
The engineering part of this work is in the backend setup, local model hosting, environment configuration, and getting the workflow to run reliably on one machine.
- Convo-AI runs a FastAPI backend with Ollama locally for chat workflows.
- No services are hosted for external users; all workloads run locally.
Documentation + prompts
I treat prompt work like another engineering artifact: useful only if it is documented, reproducible, and paired with manual review.
- Prompt libraries and README logs documenting which content was AI-drafted and which content was manually edited.
- Projects include TODOs for evaluation, safety, and more reliable workflow control.
Proof on GitHub
Convo-AI
Engineering focus: FastAPI backend, local model workflow, environment variables, and end-to-end local setup.
- FastAPI backend + simple UI for local chat flows.
- Uses Ollama models and environment variables documented in the repo.
- Disclosure: AI drafted the initial version of most endpoints; prompts and subsequent edits are documented in the README.
AI workflow notes
Engineering focus: how prompts, validation, disclosure, and manual review fit into the build process instead of replacing it.
- Documented how I structure AI-assisted builds and where I still rely on manual checks.
- Focus is on transparency regarding what AI drafted and what was rewritten manually.
What I’m experimenting with
Each repository labels working features versus experimental or aspirational features to indicate maturity level.
What I still need to learn
- Responsible AI guardrails (policy checks, escalation paths) in production environments.
- Measuring ROI beyond “this feels faster on my laptop.”
- Scaling prompt orchestration with queues, storage, and audit requirements.
- Security/privacy reviews for AI features before they reach real users.
If you mentor junior engineers on applied AI or automation, I am open to pairing sessions.
Core Responsibilities
An AI & Automation Engineer is responsible for building, integrating, and maintaining automated workflows and AI-powered features. Key responsibilities include:
- LLM integration: Connecting applications to large language model APIs (OpenAI, Anthropic) for chat, summarization, and extraction tasks.
- Agent workflow design: Orchestrating multi-step AI agent pipelines using frameworks like LangChain for tool use, retrieval, and reasoning chains.
- Local model hosting: Running open-weight models locally with Ollama for development and prototyping without external API costs.
- Backend service development: Building REST APIs with FastAPI to serve AI endpoints with typed validation and automatic OpenAPI docs.
- Prompt engineering and documentation: Treating prompts as versioned engineering artifacts with documented inputs, expected outputs, and manual review checkpoints.
- Evaluation and safety: Designing evaluation workflows to detect hallucinations, measure output quality, and enforce safety guardrails before features reach users.
- Automation scripting: Writing Python and Node.js scripts to automate content pipelines, data processing, and repetitive development tasks.
Key Skills
- Programming languages: Python (Source), JavaScript/TypeScript (Source)
- Web frameworks: FastAPI (Source), Express.js (Source)
- AI/ML frameworks: LangChain (Source), Ollama (Source)
- LLM APIs: OpenAI API (Source), Anthropic API (Source)
- Vector stores: Supabase pgvector (Source), Chroma (Source)
- CI/CD: GitHub Actions (Source)
- Evaluation: RAGAS for RAG evaluation (Source), manual review workflows
Tools and Technologies
| Tool | Category | My Maturity Level | Official Docs |
|---|---|---|---|
| Python + FastAPI | Backend framework | Learning | FastAPI |
| Node.js / Express | Backend framework | Prototypes | Express |
| LangChain | LLM orchestration | Exploring | LangChain |
| Ollama | Local LLM hosting | Local only | Ollama |
| OpenAI API | LLM API | Experiments | OpenAI |
| Anthropic API | LLM API | Experiments | Anthropic |
| Supabase | Vector store / BaaS | Exploring | Supabase |
| GitHub Actions | CI/CD | Small deploys | GitHub Actions |
Role Comparison: AI Automation Engineer vs. Adjacent Roles
| Dimension | AI Automation Engineer | ML Engineer | Backend Engineer | Data Engineer |
|---|---|---|---|---|
| Primary focus | LLM integrations, agent workflows, automation | Model training, fine-tuning, ML pipelines | APIs, databases, server logic | Data pipelines, ETL, warehousing |
| Core languages | Python, JavaScript | Python, R | Python, JavaScript, Go | Python, SQL, Scala |
| Key frameworks | LangChain, FastAPI, Ollama | PyTorch, TensorFlow, scikit-learn | Express, FastAPI, Django | Airflow, dbt, Spark |
| AI involvement | High — API integration and orchestration | High — model building and training | Low — may consume AI APIs | Low — data prep for ML teams |
| Infrastructure | Local models, API calls, vector stores | GPU clusters, training pipelines | Servers, databases, caches | Data warehouses, lakes |
| Typical deliverable | Working AI feature or automation script | Trained model with metrics | Deployed API service | Data pipeline or warehouse |
| My current level | Local experiments, documented prompts | Not pursuing | Small deployed APIs | Not pursuing |
Expanded Process Notes
How I approach an AI automation project
- Define the problem in plain language — Write down what the automation or AI feature should accomplish and what a successful output looks like.
- Choose local vs. API — For prototyping, I use Ollama to run models locally for zero-cost iteration. For quality-critical outputs, I test against OpenAI or Anthropic APIs.
- Build the backend scaffold — I use FastAPI because it provides automatic request validation, typed responses, and generated OpenAPI documentation (Source).
- Document prompts as artifacts — Each prompt is stored with its version, inputs, expected output, and manual review notes in the repository README.
- Add evaluation checkpoints — Before shipping, I run manual evaluation passes to check for hallucinations, off-topic responses, and format violations.
- Disclose AI assistance — Any code drafted by AI tools is labeled in the README with the prompt used and the edits I made manually.
Common pitfalls I have encountered
- Hallucinated API calls: LLMs sometimes generate plausible-looking but non-existent library functions. Manual review of generated code is mandatory (Source).
- Cold start latency: Free-tier hosting (e.g., Render) can take several minutes to wake up, which breaks chat workflows. Documenting this in the README sets correct expectations.
- Token cost surprises: Without explicit token limits, long conversations can exceed free-tier API quotas. Setting
max_tokensand truncating context is essential (Source).
