Eladio Caritos

Building a Frictionless Capture System: Voice Memos to Obsidian

2025-11-15T00:00:00+00:00

"Our brains are for having ideas, not holding them."

This principle, from Jeff Su's C.O.R.E productivity system taught to thousands of Googlers, resonated with me immediately. The C.O.R.E system starts with Capture—immediately recording information before it's forgotten. But capture only works if it's truly frictionless.

After watching his explanation of how capture should be "a reflex, not a decision," I realized my current capture workflow had too much friction. So I built something better.

The Problem I Wanted to Solve</h2>
Ideas don't wait for convenient moments. They show up while running, driving, or carrying groceries. My previous capture methods all had friction:

Physical notebook: Forgotten at home, requires stopping to write</li>
Phone notes app: Unlock phone, find app, type with thumbs</li>
Email to myself: Clutters inbox, awkward to process later</li>
Task management apps: Too many taps and required fields</li> </ul>
The Apple Watch partially solved this—I can record voice memos hands-free in seconds. But voice memos alone just create a different problem: they pile up unprocessed in the Voice Memos app instead of living in my Obsidian vault where I actually work.
I needed the memos transcribed, tagged with metadata, and automatically filed in Obsidian.
The Solution: Automated Transcription Pipeline</h2>
I built a system that bridges the gap between Apple Watch capture and Obsidian organization:

Capture: Record voice memo on Apple Watch (2 seconds, hands-free)</li>
Automatic sync: Voice memo syncs to Mac via iCloud</li>
Scheduled processing: Cron job runs my Python script</li>
AI transcription: OpenAI's Whisper converts audio to text</li>
Smart filing: Saves to Obsidian with rich metadata</li>
Cleanup: Deletes original voice memo</li> </ol>
The entire process runs automatically. I capture the thought, and later it appears in my Obsidian vault, transcribed and ready to process.
Technical Implementation</h2>
The Core Script</h3>
I wrote a Python script using OpenAI's Whisper for transcription. Whisper runs locally (no API costs) and handles various audio formats and languages automatically.
Key features:

Batch processing: Processes all pending voice memos in one run</li>
Multiple model sizes: Trade speed for accuracy (tiny/base/small/medium/large)</li>
Flexible output formats: txt, srt, vtt, or json</li>
Audio preservation: Optionally copies original audio alongside transcription</li>
Safe cleanup: Only deletes originals after successful transcription</li> </ul>
Metadata Generation</h3>
The script extracts timestamps from Voice Memo filenames (format: 20250505 072813-DADFB99E.m4a</code>) and generates Obsidian frontmatter:
--- who: - "[[~eladio]]" what: - "[[%voice]]" - "[[%memo]]" when: - "[[@2025]]" - "[[@2025-05]]" - "[[@2025-05-05]]" - "[[@2025-W18]]" - "[[@2025-05-05 07:28:13]]" where: - "[[+stony-brook]]" - "[[+new-york]]" status: - "[[!archive]]" visibility: - "[[!private]]" --- </code></pre> This rich metadata means I'll be able to query voice memos by date, week, location, or type using Obsidian's Dataview queries. The Automation</h3> A simple shell script orchestrates the workflow: #!/bin/bash VOICE_MEMOS_DIR="/Users/eladio/Library/Group Containers/group.com.apple.VoiceMemos.shared/Recordings" OUTPUT_DIR="$HOME/src/transcribe-voice-memos/transcriptions" cd "$HOME/src/transcribe-voice-memos" source venv/bin/activate python transcribe_voice_memos.py "$VOICE_MEMOS_DIR" \ --batch \ --output "$OUTPUT_DIR" \ --copy-audio \ --delete-after </code></pre> Running this via cron means transcriptions appear automatically without any manual work. Why This Aligns with C.O.R.E</h2> Jeff Su's system emphasizes that capture should be "a reflex, not a decision." This automation should achieve exactly that: No Decision Required: I won't need to think about where to file it, how to categorize it, or whether it's "important enough." Just speak and move on. Offload Immediately: The thought leaves my brain and enters my external system instantly. No mental carrying until I can "properly" write it down. Separate Capture from Processing: I capture in the moment. I organize and review later during dedicated sessions at my desk. Each step happens when it's most effective. Trust Through Automation: Because it's automated and reliable, I can trust it completely. This trust removes hesitation—I won't second-guess whether to use it. The Technical Stack</h2> For anyone wanting to build something similar: Python 3.13 with virtual environment</li> OpenAI Whisper (open source, runs locally—no API costs)</li> PyTorch for machine learning backend</li> Shell scripts for orchestration</li> Cron for scheduling (could use macOS Launch Agents)</li> </ul> The complete project lives at ~/src/transcribe-voice-memos/</code> and is relatively straightforward to adapt for other note-taking systems. Configuration Options</h2> The script is flexible: Model Selection (trading speed for accuracy): tiny</code>: Fastest, good for simple ideas</li> base</code>: My default, solid balance</li> medium</code>: Better for technical terms</li> large</code>: Best accuracy, slower</li> </ul> Output Formats: txt</code>: Markdown with frontmatter (my choice)</li> srt</code>: Subtitle format with timestamps</li> vtt</code>: WebVTT format</li> json</code>: Full structured data</li> </ul> Processing Modes: Auto-delete originals (clean workflow)</li> Keep originals (redundant backup)</li> Copy audio files (my approach—transcription plus original for reference)</li> </ul> Ideas for Future Enhancement</h2> I'm already thinking about improvements: Intelligent Categorization: Use GPT to analyze memo content and automatically categorize (work, personal, ideas, todos) and route to appropriate Obsidian folders. Immediate Processing: Integrate with iOS Shortcuts to trigger transcription right after recording instead of waiting for the next cron run. Voice Commands: Parse commands embedded in memos ("File this as a project idea" or "Add to shopping list") and act on them. Task Extraction: Automatically create Obsidian tasks when memos contain phrases like "TODO" or "Remember to..." The Design Philosophy: Eliminate Friction</h2> This project reinforced an important lesson: good productivity tools aren't about features—they're about removing friction. The Apple Watch already existed. Obsidian already existed. Voice memos were already being created. Transcription technology was already available. The friction was in the gaps between tools: manually transcribing audio, copying files, adding metadata, organizing notes. By automating those gaps, the workflow becomes frictionless. And frictionless capture, as the C.O.R.E system teaches, is the foundation of effective productivity. Getting Started</h2> If you want to build something similar: Set up Python environment: python -m venv venv</code></li> Install dependencies: pip install openai-whisper torch</code></li> Write a script to process voice memos from Apple's directory</li> Generate appropriate metadata/frontmatter for your system</li> Create automation (cron job or Launch Agent)</li> Test thoroughly before enabling auto-deletion</li> </ol> The setup takes a few hours, but creates a system that should pay dividends over time. What's Next</h2> I just built this system, so I can't yet report on real-world effectiveness. But the theory is sound: Capture should be effortless</li> Processing should be separate from capture</li> Automation removes friction</li> Trust in the system enables reflexive use</li> </ul> I'll be testing this workflow over the coming weeks and will share results in a future post. If it works as designed, it should capture ideas that would otherwise be lost while keeping my Obsidian vault as the single source of truth. The real test will be whether I naturally reach for voice memos when ideas strike, or if friction still creeps in. Time will tell. The code for this project is available at ~/src/transcribe-voice-memos/</code>. I'll write a follow-up post once I've used this system in real-world conditions and can share actual results rather than theoretical benefits.



Row Level Security (RLS) in Expo + Supabase: Your Backend Access Control
2025-09-07T00:00:00+00:00
When building mobile apps with Expo and Supabase, Row Level Security (RLS) becomes your primary defense mechanism for data access control. Since your mobile app connects directly to the database through Supabase's API, RLS policies act as your backend security layer.</p>
What is RLS?</h2>
Row Level Security is a Postgres feature that lets you define rules (policies) for who can access or modify specific rows in a table. Instead of granting blanket table permissions, you can create fine-grained access control based on user identity, roles, or any other criteria.</p>
In your Expo + Supabase stack:</p>

Database</strong>: Supabase (Postgres with RLS)</li>
Frontend</strong>: Expo (React Native)</li>
Auth</strong>: Supabase Auth with JWT tokens</li>
</ul>
How RLS Works in Your App Flow</h2>

User authenticates</strong> via Supabase Auth and receives a JWT token</li>
Expo app makes requests</strong> to Supabase with that token</li>
RLS policies inspect</strong> the JWT's sub</code> (user ID), roles, and other claims</li>
Postgres returns</strong> only rows that match your policy rules</li>
</ol>
This means you don't need a separate API layer for basic access control - RLS handles it at the database level.</p>
Common RLS Policy Patterns</h2>
User-Owned Data Access</h3>
The most common pattern: users can only access their own data.</p>
-- Enable RLS on the table
</span>ALTER TABLE </span>profiles ENABLE ROW LEVEL SECURITY;
</span>
</span>-- Users can only see their own profile
</span>CREATE POLICY "</span>Users can view own profile</span>" ON profiles
</span>FOR </span>SELECT USING</span> (</span>auth</span>.</span>uid</span>() = id);
</span>
</span>-- Users can only update their own profile  
</span>CREATE POLICY "</span>Users can update own profile</span>" ON profiles
</span>FOR </span>UPDATE USING</span> (</span>auth</span>.</span>uid</span>() = id);
</span>
</span>-- Users can insert their own profile
</span>CREATE POLICY "</span>Users can insert own profile</span>" ON profiles
</span>FOR </span>INSERT WITH CHECK</span> (</span>auth</span>.</span>uid</span>() = id);
</span></code></pre>
Public Read, Private Write</h3>
Perfect for public profiles or posts where anyone can read but only owners can modify.</p>
-- Anyone can read profiles
</span>CREATE POLICY "</span>Profiles are publicly readable</span>" ON profiles
</span>FOR </span>SELECT USING</span> (</span>true</span>);
</span>
</span>-- Only profile owners can update
</span>CREATE POLICY "</span>Users can update own profile</span>" ON profiles  
</span>FOR </span>UPDATE USING</span> (</span>auth</span>.</span>uid</span>() = user_id);
</span></code></pre>
Relationship-Based Access</h3>
For data involving multiple users, like messages or shared documents.</p>
-- Users can read messages they sent or received
</span>CREATE POLICY "</span>Users can read their messages</span>" ON messages
</span>FOR </span>SELECT USING</span> (
</span>  </span>auth</span>.</span>uid</span>() = sender_id OR </span>auth</span>.</span>uid</span>() = receiver_id
</span>);
</span>
</span>-- Users can only send messages as themselves
</span>CREATE POLICY "</span>Users can send messages</span>" ON messages
</span>FOR </span>INSERT WITH CHECK</span> (</span>auth</span>.</span>uid</span>() = sender_id);
</span></code></pre>
Implementing RLS in Your Expo App</h2>
The beauty of RLS is that your Expo code remains clean and simple:</p>
// This query automatically respects RLS policies
</span>const </span>{ </span>data</span>, </span>error </span>} = </span>await </span>supabase
</span>  .</span>from</span>('</span>profiles</span>')
</span>  .</span>select</span>('</span>*</span>');
</span>
</span>// Only returns profiles the user is allowed to see
</span>// No need for manual filtering or authorization checks
</span></code></pre>
For real-time subscriptions:</p>
// Subscriptions also respect RLS
</span>const </span>subscription </span>= </span>supabase
</span>  .</span>channel</span>('</span>profiles</span>')
</span>  .</span>on</span>('</span>postgres_changes</span>', 
</span>    { event: '</span>*</span>', schema: '</span>public</span>', table: '</span>profiles</span>' },
</span>    (</span>payload</span>) </span>=> </span>console</span>.</span>log</span>('</span>Change received!</span>', </span>payload</span>)
</span>  )
</span>  .</span>subscribe</span>();
</span></code></pre>
Advanced Patterns</h2>
Role-Based Access</h3>
-- Create a function to get user role
</span>CREATE OR REPLACE FUNCTION </span>get_user_role</span>()
</span>RETURNS </span>text </span>AS $$
</span>  </span>SELECT</span> raw_user_meta_data->>'</span>role</span>' 
</span>  </span>FROM </span>auth</span>.</span>users 
</span>  </span>WHERE</span> id = </span>auth</span>.</span>uid</span>()
</span>$$ LANGUAGE sql SECURITY DEFINER;
</span>
</span>-- Admin users can see all profiles
</span>CREATE POLICY "</span>Admins can view all profiles</span>" ON profiles
</span>FOR </span>SELECT USING</span> (get_user_role() = '</span>admin</span>');
</span></code></pre>
Time-Based Access</h3>
-- Users can only edit posts within 24 hours of creation
</span>CREATE POLICY "</span>Users can edit recent posts</span>" ON posts
</span>FOR </span>UPDATE USING</span> (
</span>  </span>auth</span>.</span>uid</span>() = author_id AND 
</span>  created_at > now() - interval '</span>24 hours</span>'
</span>);
</span></code></pre>
Testing Your RLS Policies</h2>
Always test with actual user tokens, not the service role key:</p>
// Create a test user
</span>const </span>{ </span>data</span>: </span>user </span>} = </span>await </span>supabase</span>.</span>auth</span>.</span>signUp</span>({
</span>  email: '</span>test@example.com</span>',
</span>  password: '</span>password</span>'
</span>});
</span>
</span>// Make requests as that user to verify policies work
</span>const </span>{ </span>data </span>} = </span>await </span>supabase
</span>  .</span>from</span>('</span>profiles</span>')
</span>  .</span>select</span>('</span>*</span>');
</span></code></pre>
Important Gotchas</h2>

Default Deny</strong>: Once RLS is enabled, all access is blocked until you create policies</li>
Service Role Bypasses RLS</strong>: Server-side functions using the service key ignore RLS</li>
Policy Order Matters</strong>: More specific policies should come first</li>
Performance</strong>: Complex policies can impact query performance</li>
</ol>
Security Benefits</h2>
With proper RLS policies, you get:</p>

Data isolation</strong> between users automatically</li>
Protection against</strong> client-side tampering or reverse engineering</li>
Consistent security</strong> across all database access points</li>
Real-time security</strong> for subscriptions and live updates</li>
</ul>
RLS transforms Supabase from just a database-as-a-service into a secure backend-as-a-service, making it perfect for mobile apps that need robust data protection without the complexity of building custom APIs.</p>
The key is starting with simple policies and gradually adding complexity as your app's requirements grow. Your Expo app stays clean while Postgres handles the heavy lifting of access control.</p>


Automating My Tennis Shoe Shopping: Because Even Athletes Need Automation
2025-09-03T00:00:00+00:00
As someone who plays tennis regularly, I've learned that replacing tennis shoes every 6 months isn't just a recommendation—it's essential for both performance and injury prevention. But I don't want shoe shopping to be another recurring task on my mental to-do list.</p>
So I did what any programmer would do: I automated it.</p>
The Why</h1>
Tennis shoes lose their cushioning and support over time, and for someone who plays multiple times per week, that degradation happens faster than you might think. The general rule is every 6 months or 300-500 hours of play, whichever comes first.</p>
I know I need new shoes regularly. I just don't want to think about it. Shopping for shoes, comparing prices, checking inventory - it's all time and mental energy I'd rather spend elsewhere. So I automated the entire process.</p>
The Solution</h1>
I created an open source project that handles the entire tennis shoe replacement cycle:</p>

Automated scheduling</strong> - Tracks when it's time for replacement based on your play frequency</li>
Price monitoring</strong> - Watches multiple retailers for your preferred models and sizes</li>
Inventory tracking</strong> - Alerts you when your shoes are in stock at the best price</li>
Purchase automation</strong> - Can automatically order when conditions are met</li>
Performance analytics</strong> - Tracks how different shoes perform over their lifecycle</li>
</ul>
Key Features</h2>
Smart Scheduling</strong>: The system learns from your play patterns. Log your court time, and it calculates optimal replacement timing based on actual usage rather than just calendar months.</p>
Multi-Retailer Monitoring</strong>: Checks major tennis retailers, Amazon, and direct manufacturer sites for price drops and availability.</p>
Model Intelligence</strong>: Maintains a database of tennis shoe models with performance ratings, durability data, and user reviews to suggest the best options for your playing style.</p>
Budget Optimization</strong>: Finds the sweet spot between shoe quality and cost, factoring in how long different models last under your specific playing conditions.</p>
Why This Matters</h1>
Beyond the obvious convenience factor, this project solves several real problems:</p>
Injury Prevention</strong>: Worn-out shoes are a major cause of tennis injuries. Automated replacement ensures you're always playing in properly supportive footwear.</p>
Performance Consistency</strong>: Fresh shoes mean consistent traction and comfort, which translates to better play and fewer distractions on court.</p>
Cost Efficiency</strong>: By monitoring prices continuously, the system catches sales and deals you'd otherwise miss, often saving 20-30% compared to emergency purchases.</p>
Time Savings</strong>: No more shopping around or trying to remember when you last bought shoes. The system handles everything.</p>
The Technical Implementation</h1>
The project is built with modularity in mind:</p>

Scheduling Engine</strong>: Configurable algorithms for calculating replacement timing</li>
Web Scraping Framework</strong>: Robust price and inventory monitoring across retailers</li>
Notification System</strong>: Alerts via email, SMS, or push notifications</li>
Purchase Integration</strong>: Secure API connections to supported retailers</li>
Analytics Dashboard</strong>: Track spending, shoe performance, and play patterns</li>
</ul>
Open Source Approach</h2>
I've open-sourced this because the tennis community (and athletes in general) shouldn't have to solve these problems individually. The project is designed to be:</p>

Extensible</strong>: Easy to add new retailers or shoe models</li>
Configurable</strong>: Adaptable to different sports, playing frequencies, and budgets</li>
Privacy-Focused</strong>: All data stays local or in your chosen cloud provider</li>
Community-Driven</strong>: Feature requests and improvements from actual players</li>
</ul>
Getting Started</h1>
The system is designed for easy setup:</p>

Configure your playing schedule and preferred shoe models</li>
Set up retailer monitoring for your size and budget range</li>
Choose notification preferences and automation level</li>
Let the system handle the rest</li>
</ol>
You can run it fully automated or use it as a monitoring tool with manual purchase decisions—whatever fits your comfort level.</p>
Real-World Results</h1>
Since implementing this system:</p>

Zero missed replacement windows</strong> - No more playing in worn-out shoes</li>
25% average savings</strong> on shoe purchases through automated deal detection</li>
Eliminated decision fatigue</strong> - No more spending hours comparing options</li>
Better performance tracking</strong> - Data on how different shoes perform over time</li>
</ul>
The Future</h1>
This is just the beginning. Future versions could include:</p>

Biomechanical integration</strong> - Using wearable data to predict optimal replacement timing</li>
Community recommendations</strong> - Leveraging user data to suggest optimal shoes for different playing styles</li>
Injury correlation</strong> - Tracking relationships between shoe condition and injury patterns</li>
Multi-sport support</strong> - Expanding beyond tennis to other athletic footwear</li>
</ul>
Contributing</h1>
The project is available on GitHub and welcomes contributions from developers and athletes alike. Whether you're interested in adding support for new sports, improving the price monitoring algorithms, or just reporting bugs, the tennis community benefits from everyone's input.</p>

Tennis players spend countless hours perfecting their game—their equipment maintenance should be just as optimized. If you're tired of manual shoe shopping or have ideas for improving athletic gear automation, check out the project and contribute!</em></p>


My Car Buying Experience: From a Worn Odyssey to a New Sienna
2025-09-02T00:00:00+00:00
The Search Begins</h1>
After 14 years with our 2011 Honda Odyssey approaching 200,000 miles, it was time for a change. The reliability issues were piling up: the battery would die even after charging, both sliding doors had to be operated manually (and the kids would often leave them ajar), the backup camera was dead, and one A/C vent wasn't working properly. After over a decade of faithful service, our minivan was showing its age.</p>
Research Phase</h1>
The process of choosing a replacement was arduous. My wife and kids wanted a large SUV, while my youngest and I were team minivan.</p>
Initially, I set my sights on the Hybrid Grand Highlander, but finding one without a significant market markup proved nearly impossible. This led me to explore large SUVs like the Toyota Sequoia and Cadillac Escalade. For a while, we seriously considered the Chevrolet Tahoe - we even rented one in Florida for a week and loved it. But reality set in: the thing was massive. How would I navigate tight city spots? Where would I even park it?</p>
These practical concerns led me back to minivans. When I discovered that Toyota had given the Sienna a major electronic upgrade and made it a hybrid, I was increasingly sold.</p>
What I Was Looking For</h2>
Must-haves:</strong></p>

7-8 seats to accommodate our large family plus occasional guests</li>
Reliability and dependability</li>
Good fuel economy</li>
Reasonable maintenance costs</li>
</ul>
The Shopping Experience</h1>
Working with dealerships was frustrating. They'd present spec sheets where the numbers didn't add up, sneaking in "market adjustment fees" due to high demand. Most wouldn't budge on price - it was take it or leave it.</p>
Test Drives</h2>
I test drove the Toyota Grand Highlander and Cadillac Escalade. Both had their merits, but neither felt quite right for our needs.</p>
The Decision</h1>
I ultimately chose the 2025 Toyota Sienna XLE. It checked all our practical boxes without the bulk of a full-size SUV.</p>
Negotiation Process</h2>
I contacted multiple dealerships, and most were still tacking on $5,000+ market adjustment fees. Eventually, I found one willing to sell at MSRP with no extra fees - a win in today's market.</p>
A word of warning: the dealership will claim they have the best financing rates. Don't take their word for it. I ended up financing through Teachers Federal Credit Union at a lower rate than what the dealer offered.</p>
Final Thoughts</h1>
The biggest lesson? Don't rush. Taking your time is your best negotiating tactic. Dealers can sense desperation, and in a seller's market, patience is your only leverage.</p>
Tips for Future Car Buyers</h2>

Know your needs vs. wants</strong> - A week-long rental really helped us understand what living with a particular vehicle would be like</li>
Shop around for financing</strong> - Credit unions often beat dealer rates</li>
Be patient</strong> - In a market with markups, the dealer who doesn't add fees is worth waiting for</li>
Consider total cost of ownership</strong> - Fuel economy and maintenance costs add up over time</li>
</ol>
The Car</h1>
2025 Toyota Sienna XLE. Nothing fancy, just practical. It's the perfect blend of space, efficiency, and reliability that our family needs. Sometimes the smartest choice isn't the flashiest one.</p>


Real-time Log Monitoring with Claude Code and Expo
2025-08-21T00:00:00+00:00
One of the most powerful workflows I've discovered while developing React Native apps with Claude Code is using real-time log monitoring. This simple technique has saved me countless hours of debugging and development time.</p>
The Problem</h2>
When developing React Native apps with Expo, you're often juggling multiple things:</p>

Writing code</li>
Running the development server</li>
Monitoring console logs</li>
Debugging errors</li>
Testing on simulators or devices</li>
</ul>
Traditionally, this means constantly switching between your code editor and terminal to check logs, understand errors, and debug issues. It's a context-switching nightmare that slows down development.</p>
The Solution: Real-time Log Piping</h2>
Here's the game-changing command I use:</p>
npx</span> expo start > logs/expo.log </span>2</span>>&</span>1
</span></code></pre>
This simple command redirects all Expo server output (both stdout and stderr) to a log file that Claude Code can monitor in real-time.</p>
Why This Works So Well</h2>


Claude Code can see everything</strong>: By piping logs to a file, Claude Code can read and analyze the entire output history, not just what's currently visible in your terminal.</p>
</li>

Context-aware debugging</strong>: When an error occurs, Claude Code can immediately see:</p>

The full error stack trace</li>
What was happening before the error</li>
Related warnings or logs</li>
The exact file and line number</li>
</ul>
</li>

Proactive problem-solving</strong>: Claude Code often catches issues before I even notice them. It can spot deprecation warnings, performance issues, or potential bugs in the log output.</p>
</li>

No more copy-pasting</strong>: Instead of copying error messages to ask Claude Code about them, it already has the full context and can suggest fixes immediately.</p>
</li>
</ol>
Setting It Up</h2>


Create a logs directory in your project:</p>
mkdir -p</span> logs
</span></code></pre>
</li>

Add logs/</code> to your .gitignore</code>:</p>
logs/
</span></code></pre>
</li>

Start your Expo server with log redirection:</p>
npx</span> expo start > logs/expo.log </span>2</span>>&</span>1
</span></code></pre>
</li>

In a Claude Code session, ask it to monitor the logs:</p>
"Can you check the Expo logs at logs/expo.log and help me debug any issues?"
</span></code></pre>
</li>
</ol>
Real-World Examples</h2>
Example 1: Mysterious App Crashes</h3>
My app was crashing intermittently on Android. Instead of spending hours adding console.logs everywhere, I just asked Claude Code to analyze the log file. It immediately spotted a memory leak pattern in the logs that I had missed.</p>
Example 2: Performance Optimization</h3>
Claude Code noticed repeated warnings about large lists being rendered without optimization. It not only identified the issue but also suggested implementing FlatList</code> with proper keyExtractor</code> and getItemLayout</code> props.</p>
Example 3: Dependency Conflicts</h3>
When upgrading Expo SDK versions, the logs showed various compatibility warnings. Claude Code read through all of them and provided a step-by-step plan to resolve each conflict.</p>
Tips for Maximum Effectiveness</h2>


Keep logs focused</strong>: Clear your log file periodically to keep it manageable:</p>
echo </span>"" > logs/expo.log
</span></code></pre>
</li>

Use descriptive console.logs</strong>: Add meaningful log messages in your code. Claude Code can use these as context clues.</p>
</li>

Let Claude Code be proactive</strong>: Don't wait for errors. Ask Claude Code to periodically check the logs for warnings or potential issues.</p>
</li>

Combine with other tools</strong>: This workflow pairs excellently with React Native Debugger and Expo's built-in tools.</p>
</li>
</ol>
Beyond Expo</h2>
This pattern works for any development server or long-running process:</p>

Next.js: npm run dev > logs/next.log 2>&1</code></li>
Node.js apps: node server.js > logs/server.log 2>&1</code></li>
Docker containers: docker-compose logs -f > logs/docker.log 2>&1</code></li>
</ul>
Conclusion</h2>
This simple logging technique has transformed how I work with Claude Code. Instead of being reactive to errors, we can be proactive. Instead of losing context in terminal scrollback, we have a persistent record. Instead of manually copying errors, Claude Code already has the full picture.</p>
Give it a try on your next project. You might be surprised how much time it saves you.</p>


Building Mobile Apps with Claude Code: A Game-Changing Development Experience
2025-07-20T00:00:00+00:00
I've been experimenting with Claude Code for mobile app development recently, and I have to say—it's been a remarkable experience that's fundamentally changing how I approach building cross-platform mobile applications. If you're a mobile developer who hasn't tried Claude Code yet, you're missing out on what might be the most significant productivity boost since Expo made React Native development accessible to TypeScript developers.</p>
Learning from Previous AI Development Failures</h2>
I'll be honest—this isn't my first attempt at building an app with AI assistance. I've had multiple unsuccessful attempts in the past where I'd jump straight into asking AI tools to generate code, only to end up with fragmented, inconsistent implementations that didn't work together as a cohesive application. The problem wasn't the AI—it was my approach.</p>
The key difference this time? Planning before coding.</strong></p>
Instead of diving headfirst into code generation, I spent considerable time creating a comprehensive project structure that provides the AI with the context it needs to build something meaningful. Here's what I've learned makes all the difference:</p>
The Foundation: Comprehensive Project Documentation</h3>
Before writing a single line of code, I created several key organizational files:</p>
CLAUDE.md</strong> - This file contains essential development information and context that helps Claude Code understand my project's architecture, coding conventions, and specific requirements. It's like giving the AI a thorough onboarding document.</p>
TODO.md</strong> - A detailed task list that breaks down the app development into manageable chunks. This ensures nothing gets forgotten and provides a clear roadmap for both me and Claude Code to follow.</p>
wireframes/</strong> directory - Visual representations of what each screen should look like. Screenshots, mockups, and UI sketches that give Claude Code a clear understanding of the desired user interface.</p>
flows/</strong> directory - Detailed descriptions of user interactions and navigation patterns. These documents describe how users move through the app, what happens when they tap buttons, and how different features connect together.</p>
Why Context Changes Everything</h3>
What I discovered is that AI code generation is only as good as the context you provide. My previous attempts failed because I was asking for isolated pieces of functionality without explaining how they fit into the bigger picture. It's like asking someone to write a chapter of a book without telling them what the book is about.</p>
With this structured approach, Claude Code doesn't just generate code—it generates code that fits seamlessly into my app's architecture. It understands the user flows, respects the design patterns I've established, and maintains consistency across different features.</p>
The Planning Payoff</h3>
This upfront investment in planning and documentation has paid dividends:</p>

Coherent architecture</strong> - Every component fits together logically</li>
Consistent UI/UX</strong> - The app feels like it was designed by a single team</li>
Fewer integration issues</strong> - New features work seamlessly with existing code</li>
Better debugging</strong> - When issues arise, they're easier to trace and fix</li>
Maintainable codebase</strong> - The code follows established patterns and conventions</li>
</ul>
What Makes Claude Code Special for Mobile Development</h2>
Claude Code isn't just another AI coding assistant. It's a comprehensive development environment that understands the nuances of modern mobile development, from React Native component patterns to Expo's managed workflow intricacies. What sets it apart is its ability to not just write code, but to understand the broader context of full-stack mobile app architecture—from frontend React Native components to Supabase backend integration.</p>
Real-Time Code Generation and Component Creation</h3>
One of the most impressive features is how Claude Code can generate entire React Native components based on simple descriptions. I recently asked it to create a custom tab navigation component with smooth animations, and it delivered production-ready code that would have taken me hours to write and debug. The component included proper TypeScript interfaces, accessibility features, and smooth animations—all from a basic description of what I wanted.</p>
Accelerating Complex Features</h2>
Supabase Integration Made Simple</h3>
Building robust backend integration is traditionally one of the more time-consuming aspects of mobile development. Claude Code excels at creating clean, maintainable Supabase integration code that handles authentication, real-time subscriptions, and database operations. It understands the nuances of Supabase's client libraries and can generate comprehensive service classes with proper error handling and TypeScript types.</p>
Expo-Specific Features and Navigation</h3>
One area where Claude Code really shines is in understanding Expo's ecosystem. It can generate navigation setups using Expo Router, handle device capabilities, and integrate with Expo's managed services. Whether it's setting up authentication flows, configuring app builds, or implementing platform-specific features, Claude Code understands the Expo workflow and generates code that follows best practices.</p>
The Learning Amplifier</h2>
What I find most valuable about Claude Code isn't just that it writes code for me—it's that it explains the why</em> behind architectural decisions. When I ask for a particular implementation, it doesn't just provide the code; it explains the trade-offs, suggests alternatives, and helps me understand React Native and Expo development patterns I might not have encountered otherwise.</p>
Testing and Quality Assurance</h3>
Claude Code has also improved my testing practices. It generates comprehensive Jest tests for React Native components and can even suggest testing scenarios for Expo-specific features. The tests it creates are thorough and follow testing best practices, covering edge cases I might not have considered on my own.</p>
Real-World Impact</h2>
Since incorporating Claude Code into my mobile development workflow, I've seen:</p>

50% reduction in development time</strong> for new features</li>
Significantly fewer bugs</strong> due to better code patterns and comprehensive testing</li>
Improved code quality</strong> through consistent architecture and best practices</li>
Faster learning curve</strong> when exploring new React Native libraries and Expo features</li>
</ul>
The Future of Mobile Development</h2>
Claude Code represents a paradigm shift in how we approach mobile development. It's not replacing developers—it's amplifying our capabilities and allowing us to focus on the creative and strategic aspects of app building rather than getting bogged down in boilerplate code.</p>
The combination of AI assistance with modern development tools creates a powerful synergy. Expo's development experience, Supabase's backend services, and Claude Code's intelligent code generation creates an environment where building complex cross-platform mobile apps becomes more accessible and enjoyable.</p>
Getting Started</h2>
If you're interested in trying Claude Code for mobile development, here's what I recommend based on my journey from failed attempts to success:</p>
Start with Planning, Not Coding</h3>
Before you write a single line of code, invest time in documentation:</p>

Create a CLAUDE.md file</strong> - Document your project's architecture, coding conventions, and requirements</li>
Build a comprehensive TODO.md</strong> - Break down your app into specific, manageable tasks</li>
Design wireframes</strong> - Create visual mockups of your screens, even if they're hand-drawn sketches</li>
Map user flows</strong> - Document how users navigate through your app and interact with features</li>
</ol>
Test with Small Features First</h3>
Start with a small project or feature, but make sure it's properly documented. The learning curve is minimal, and the productivity gains become apparent almost immediately when you provide proper context.</p>
Think Partnership, Not Generation</h3>
The key is to think of Claude Code as a knowledgeable pair programming partner rather than just a code generator. Give it the context it needs to understand your vision, and it will help you build something truly cohesive.</p>
The future of mobile development is here, and it's more exciting than ever. With tools like Claude Code, we're entering an era where the limitation isn't our ability to implement ideas—it's our ability to imagine them.</p>

Have you tried Claude Code for mobile development? I'd love to hear about your experiences and the kinds of apps you're building with AI assistance. Feel free to reach out and share your stories!</em></p>


A Memorable Family Adventure in Paris
2025-03-06T00:00:00+00:00
A Memorable Family Adventure in Paris</h1>
Two weeks have passed since our return to the United States, and I'm already nostalgic about our family adventure in Paris. The City of Light left an indelible mark on all of us, creating memories we'll cherish forever.</p>
The excitement began well before our departure. As an enthusiast of Rick Steves' travel philosophy and an active member of the onebag subreddit</a>, I was determined to put minimalist packing into practice. Rick's wisdom resonated with me: "Don't pack for the worst-case scenario. Pack for the best-case scenario and buy yourself out of any jams." This approach to packing smart and traveling light</a> proved invaluable throughout our journey.</p>
Our week in Paris was filled with classic attractions and unexpected delights. While we explored iconic landmarks like the Eiffel Tower, Louvre Museum, and Notre Dame, some of our most memorable moments came from simply wandering the charming streets of Paris. We embraced the local way of life, navigating the Metro and bus system like true Parisians. Following our noses to small, inviting restaurants led us to some of the most authentic and delicious meals of our trip.</p>
A highlight of our stay was fulfilling my wife's dream of experiencing dinner at the legendary Moulin Rouge. The spectacular show and ambiance made for an unforgettable evening that exceeded our expectations.</p>
Traveling with children can be challenging, but our kids were remarkable travel companions. While there were occasional moments of fatigue and resistance (as expected), we struck a balance between adult interests and child-friendly activities. This compromise helped everyone feel invested in our family adventure.</p>
For those interested in the practical details, our total expenses came to $6,850. By booking six months in advance, we secured excellent airfare at $2,300 for our family of six. Our comfortable Airbnb accommodation cost $1,300, with the remaining budget covering food, attractions, and local transportation.</p>
This Parisian adventure has reignited my passion for travel. It's remarkable how stepping out of our daily routines can refresh our perspective on life. Navigating a new city, sampling unfamiliar cuisines, and tackling unexpected challenges as a family didn't just create lasting memories – it reminded us that life's greatest moments often lie outside our comfort zone.</p>
The journey has taught us that travel isn't just about checking off tourist attractions; it's about growing together as a family and embracing new experiences with an open mind and heart. As we settle back into our routine, we're already dreaming about our next family adventure.</p>


Notes on Rust Programming Language
2025-01-05T00:00:00+00:00
Rust Programming Language</h1>
7 - Managing Growing Projects with Packages, Crates, and Modules</h2>

encapsulation

lets you reuse code at a higher level</li>
once you've implemented an operation, other code can call your code via its public interface without having to know how the implementation works</li>
</ul>
</li>
scope

the nested context in which code is written has a set of names that are defined as "in scope"</li>
</ul>
</li>
rust features to manage code organization

Packages

a cargo feature that lets you build, test, and share craftes</li>
</ul>
</li>
Crates

a tree of modules that produces a library or executable</li>
</ul>
</li>
Modules and use

let you control the organization, scope, and privacy of paths</li>
</ul>
</li>
Paths

a way of naming an item, such as a struct, function, or module</li>
</ul>
</li>
</ul>
</li>
</ul>
Packages and Crates</h3>

crate

smallest amount of code that the Rust compiler considers at a time</li>
</ul>
</li>
binary crate

programs you can compile to an executable that you can run</li>
i.e. command line program or server</li>
must have a function "main"</li>
</ul>
</li>
library crate

don't have a main function</li>
don't compile to an executable</li>
define functionality intended to be shared with multiple projects</li>
</ul>
</li>
crate root

source file that the Rust compiler starts from and makes up the root module of your crate</li>
src/main.rs</li>
src/lib.rs</li>
</ul>
</li>
package

bundle of one or more crates that provides a set of functionality</li>
contains Cargo.toml

describes how to build those crates</li>
</ul>
</li>
</ul>
</li>
</ul>
Defining Modules to Control Scope and Privacy</h3>

paths

allow you to name items</li>
</ul>
</li>
use

brings a path into scope</li>
</ul>
</li>
pub

make items public</li>
</ul>
</li>
modules

organize code within a crate for readability and easy reuse</li>
allow control of privacy of items because code within a module is private by default</li>
mod

how to define a module</li>
we can place modules inside modules</li>
</ul>
</li>
</ul>
</li>
</ul>
Paths for Referring to an item in the Module Tree</h3>

absolute path

full path starting from a crate root; for code from an external crate, the absolute path begins with the crate name, and for code from the current crate, it starts with the literal crate</li>
</ul>
</li>
relative path

starts from the current module and uses self, super, or an identified in the current module</li>
</ul>
</li>
both absolute path and relative pats are followed by one or more identifiers separated by double colons (::)</li>
</ul>
Exposing Paths with the pub Keyword</h4>

have to make nested code public as well</li>
</ul>
Starting Relative Paths with super</h4>

using "super" allows us to reference an item that we know is in the parent module, which can make rearranging the module tree easier when the module is closely related to the parent</li>
</ul>
Making Structs and Enums Public</h4>

if we use "pub" before a struct definition, we make the struct public, but the struct's fields will still be private</li>
we can make each field public or not on a case-by-case basis</li>
</ul>
Bringing Paths into Scope with the use Keyword</h3>

we can create a shortcut to a path with the use keyword once, and tehn use the shorter name everhwere else in the scope</li>
</ul>
Creating Idiomatic use Paths</h4>
Providing New Names with pub use</h4>
Re-exporting Names with pub usee</h4>
Using External Packages</h4>
Using Nested Paths to Clean Up Large use Lists</h4>
The glob operator</h4>
Separating Modules into Different Files</h3>
Summary</h3>
8 Common Collections</h2>

collections contain multiple Values</li>
unlike the built-in array and tuple types, the data that these colelctions point to is stored on the heap.</li>
amount of data does not need to be known at runtime.</li>
vector

allows you to store a varaible number of values next to each other</li>
</ul>
</li>
string

collection of characters</li>
</ul>
</li>
hash map

allows yhou tro associate a value iwth a specific key</li>
</ul>
</li>
</ul>
Storing Lists of Values with Vectors</h3>

create a new vector

let v: Vec = Vec::new();</li>
let v = vec![1,2,3];</li>
</ul>
</li>
updating a vector

use the push method

let mut v = Vec::new();</li>
v.push(5);</li>
v.push(6);</li>
v.push(7);</li>
v.push(8);</li>
</ul>
</li>
</ul>
</li>
reading elements in a vector

get an element by indexing

let third: &i32 = &v[2];</li>
</ul>
</li>
get an element by get

let third: Option<&i32> = v.get(2);</li>
</ul>
</li>
</ul>
</li>
</ul>
Stoing UTF-8 Encoded Text with Strings</h3>
Storing Keys with Associated Values in Hash Maps-</h3>


Writing Dr Mario game with Bevy
2025-01-05T00:00:00+00:00
20250106</h1>
To make things more exciting for me for the new year, I'm starting to write a rust bevy game.. I've decided on Dr. Mario.  I was at the arcade recent for my daughters birthday and they had Dr. Mario in it.  It was the game I most enjoyed.  I'm using ChatGPT to assist me in creating the bevy game.</p>


Writing a Chess Engine in Rust with the help of ChatGPT
2025-01-04T00:00:00+00:00
20250104</h1>
I've been reading the book "Rust Programming Language" but I feel I need more hands on training.  With that in mind, I thought it would be a cool project to write a chess engine.  Learning to program in Rust while working with a hobby I love would help me stick with the project.  Learning with ChatGTP by my side has been a really cool experience. It's providing step by step instructions on how to write a chess engine. I just started and I've already represented the chess board usig a 2D array.</p>


Ktor Telegram Integration
2024-08-28T00:00:00+00:00
I was listening to a Lex Fridman interview with Pietel Levels</a> and one of the tip Pieter does it send error messages to his telegram account.</p>
I was able to implement this on my ktor app pretty easily. Moving forward, I'll ping myself regarding any errors in the websites.</p>
</p>


Ktor Autoreload
2024-08-03T00:00:00+00:00
The documentation for Ktor Autoreload can be found here</a>.  I had issues wih using the EmbeddedServer so I switched to EngineMain paired with an application configuration file.</p>
To recompile on changes, i had to run the command "./gradlew -t build" and then on a separate terminal "./gradlew run"</p>

</p>


Postgres Complexity, Moving to SQLite
2024-08-02T00:00:00+00:00
I recently faced challenges with database migration and maintaining data consistency between the public version and my local system. Every time I changed the schema of some models, I found it difficult to transfer those changes from my local development environment to the public server hosted on DigitalOcean.</p>
While searching for solutions, I stumbled upon a YouTube interview with DHH on SQLite</a>. The interview made a compelling case for switching from Postgres to SQLite, which seemed to be a good fit for my current needs. With SQLite, the database is simply a file, so I only need to manage one copy at a time, simplifying the migration process significantly.</p>
Inspired by this, I’ve decided to spend today migrating my tennis app from Postgres to SQLite. This switch will help me delay confronting the complexity of database migrations and focus more on development.</p>
Stay tuned for updates on how this transition goes and any lessons learned along the way!</p>


Resume
2024-07-20T00:00:00+00:00
Objective</h1>
To secure a software engineering position in a company where my experiences, accomplishments, and proficiency will allow opportunity for growth.</p>
Experience</h1>
Architecture Engineer</em>, PASSUR Aerospace, 05/18 – 03/20</h2>

Improve the quality and agility of PASSUR Technology</li>
Select, develop, and maintain tools used in development</li>
Educate and support development and system engineering stat in their use</li>
Research new tools and processes for continuous improvement</li>
Improved Zabbix monitor by implementing agents using JMX technology using Spring Boot framework.</li>
Integrated Pacemaker, high-availability cluster resource manager to provide resource dependability.</li>
</ul>
Application Developer</em>, HBC Digital, 07/16 - 09/17</h2>

Lord & Taylor migration unto a common code base</li>
Migrating Java 6 monolith to microservices using Scala and Play framework</li>
Search implementation using Endeca
All code supports/maintains/updates the following websites:
http://www.lordandtaylor.com
http://www.saksfiftavenue.com
http://www.saksoff5th.com</li>
</ul>
Senior Software Engineer</em>, CA Technologies, 07/12 - 06/16</h2>

Updated CA InterTest’s Eclipse¬-based GUI to include C Support</li>
2nd place winner in site wide Hackathon contest.</li>
Expedite GA release of CA File Master Plus MVS Eclipse¬-based GUI</li>
Transitioning Team to Eclipse 4 for CA File Master Plus IMS Eclipse¬-based GUI</li>
Improving Team’s Code quality output by implementing TDD (using Junit / SWTBot)</li>
Implemented XML Processing via JAXB APIs, less errors in code and easier transitions with schema modifications</li>
</ul>
Software Developer</em>, Spling Inc., 08/11 - 01/12</h2>

Website development using Python (Django) & Javascript (Backbone.js / JQuery)</li>
Part of DreamIt Ventures startup incubator program in learning to build a successful startup. ¬</li>
Developed Facebook/Twitter integration into site which became the leading source for new users</li>
Developed Chrome Extension to easily post to website.</li>
</ul>
Application Programmer</em>, Adeptra, 06/09 - 03/11</h2>

Developing Customer Applications using Java and Javascript</li>
Convert Customer's documented application requirements into functional applications</li>
Created Excel Merge Tool implementing Apache POI library to decrease time developing Customer Applications.</li>
</ul>
Senior Software Engineer</em>, Nortel, 07/98 - 06/09</h2>

Second place winner for Agile Prototype Environment Developer Contest, a company wide programming competition to develop a web application that integrates with the Agile Communication Environment web services. Developed Bus Notification Service using GWT.</li>
Winner of the Enterprise Solutions Award of Distinction, an award to recognize outstanding achievements in delivering key business outcomes while demonstrating Nortel’s Core Values and behaviors.</li>
Development of Service Creation Environment, an Eclipse Plugin that graphically creates voice applications. In charge of the graphical editor portion of the Plugin, using ILOG Diagrammer’s API to implement nodes & links and the network that connects them.</li>
Developed Voice Portable Application Framework using J2EE architecture. Development includes database design and implementation using MySQL and DB2. Creating EJB component to access database and LDAP directory. JSP and Servlet development front end access to EJB component. Created Java utility that updates database through XML interface using JDOM. Implementation of SNMP interface using Java Dynamic Management Kit. Speech Recognition integration using VXML, Nuance, and Speechworks. Integrated testing through JUNIT.</li>
Programmed application encoder / decoder libraries using C/C++ for telecommunication protocols such as GR¬1129, SR¬3511, and CS1R which enables Nortel’s Intelligent Peripherals application layer to understand Abstract Syntax Notation Specification instruction.</li>
Developed and supported network application software that supports redundancy using C/C++ and shell scripting that enables Nortel’s Interactive Voice Response Systems to communicate with one or more external hosts through TCP/IP connection</li>
Developed and supported telecommunication networks and services in the Advance Intelligent Network environment. Constructed Nortel Automated National directory Assistance integrating Nuance Speech Recognition software to provide the operator with advance knowledge of the query enabling the reduction of call time, increasing customer satisfaction, and improve throughput of the system. Implemented Explicit Call Transfer supplementary service, which enables Nortel’s Voice Processing System to allow switch bridging, freeing up resources for the VPS to reuse.</li>
</ul>
Education</h1>


M.S Computer Science</em>, 2002
NYU Polytechnic School of Engineering, Brooklyn, NY</p>
</li>

B.E. Electrical Engineering</em>, 1998
State University of New York at Stony Brook, Stony Brook, NY</p>
</li>
</ul>


Embracing Docker in my Workflow
2024-07-19T00:00:00+00:00
Recently, I've integrated Docker into my development workflow. While it introduces some friction compared to my previous setup, the benefits of using Docker are worth the extra steps.</p>
Previously, I could simply press CTRL-R to run the latest code locally on my machine and test out changes instantaneously. However, with Docker, I need to execute a series of commands in the terminal:</p>
./gradlew build
</span>docker-compose build --no-cache
</span>docker-compose down
</span>docker-compose up -d
</span></code></pre>
Although these additional steps can be cumbersome, Docker provides a consistent environment for both local development and remote hosting, ensuring that my code runs smoothly across different platforms.</p>
In the next few weeks, I plan to streamline these steps to reduce friction and improve my workflow. Using Docker is a valuable investment in maintaining a consistent development environment, and I’m confident that with some adjustments, it will enhance my productivity even further.</p>


My Essential Tools for a Portable Workstation
2024-07-18T00:00:00+00:00

Hardware</h1>
As someone who likes to stay mobile, I’ve set up a portable workstation to ensure productivity wherever I go. Here's a rundown of my current setup:</p>

M1 MacBook Air: This lightweight and powerful machine is perfect for my needs. The M1 chip offers excellent performance, and the portability is unbeatable.</li>
Laptop Stand: To improve ergonomics, I use a stand that raises the screen height. This, combined with a book for extra elevation, helps reduce neck and shoulder strain—a crucial adjustment as I’ve noticed more discomfort with prolonged computer use.</li>
External Keyboard: I’m currently using an old Apple keyboard from my previous iMac. Although functional, it’s showing its age; the "esc" key no longer works, so I’ve remapped it to "F1". An upgrade might be in order soon.</li>
Bluetooth Mouse: My mouse is small and portable, featuring a scroll wheel for convenience. It’s nothing fancy but gets the job done.</li>
Bose Headphones: These headphones are essential for blocking out noise and helping me concentrate, especially in bustling environments.</li>
</ul>
Software</h1>
As a software developer, I rely on various tools to streamline my workflow:</p>

IntelliJ IDEA: After experimenting with different IDEs and spending too much time customizing nvim, I’ve settled on IntelliJ IDEA. It’s robust and user-friendly, though I’m still learning all the shortcuts. I plan to stick with it for the long term.</li>
GitHub Desktop: For Git management, I prefer GitHub Desktop over the terminal. It’s more intuitive for me and simplifies version control tasks.</li>
Firefox: I switched to Firefox as my default browser after encountering ad-blocking issues with Google Chrome. Firefox has been reliable and aligns better with my needs.</li>
Obsidian: For note-taking, Obsidian is my go-to app. I appreciate its ability to link notes and visualize connections. Plus, it’s free to use across both my phone and computer.</li>
Fantastical: This app helps me keep my calendar and to-do list organized. Its integration features make managing tasks and schedules much easier.</li>
YouTube's LOFI Girl: Background music is vital for maintaining focus, and I often listen to YouTube's LOFI girl while working.</li>
Raycast Pomodoro Timer: To enhance productivity, I’m experimenting with the Pomodoro timer in Raycast, breaking work into intervals to maintain concentration and efficiency.</li>
</ul>

Eladio Caritos

Building a Frictionless Capture System: Voice Memos to Obsidian

Technical Implementation</h2>

Row Level Security (RLS) in Expo + Supabase: Your Backend Access Control

Common RLS Policy Patterns</h2>

Advanced Patterns</h2>

Automating My Tennis Shoe Shopping: Because Even Athletes Need Automation

My Car Buying Experience: From a Worn Odyssey to a New Sienna

The Shopping Experience</h1> Working with dealerships was frustrating. They'd present spec sheets where the numbers didn't add up, sneaking in "market adjustment fees" due to high demand. Most wouldn't budge on price - it was take it or leave it.</p>

Test Drives</h2> I test drove the Toyota Grand Highlander and Cadillac Escalade. Both had their merits, but neither felt quite right for our needs.</p>

The Decision</h1> I ultimately chose the 2025 Toyota Sienna XLE. It checked all our practical boxes without the bulk of a full-size SUV.</p>

Final Thoughts</h1> The biggest lesson? Don't rush. Taking your time is your best negotiating tactic. Dealers can sense desperation, and in a seller's market, patience is your only leverage.</p>

The Car</h1> 2025 Toyota Sienna XLE. Nothing fancy, just practical. It's the perfect blend of space, efficiency, and reliability that our family needs. Sometimes the smartest choice isn't the flashiest one.</p>

Real-time Log Monitoring with Claude Code and Expo

Real-World Examples</h2>

Example 1: Mysterious App Crashes</h3> My app was crashing intermittently on Android. Instead of spending hours adding console.logs everywhere, I just asked Claude Code to analyze the log file. It immediately spotted a memory leak pattern in the logs that I had missed.</p>

Example 2: Performance Optimization</h3> Claude Code noticed repeated warnings about large lists being rendered without optimization. It not only identified the issue but also suggested implementing FlatList</code> with proper keyExtractor</code> and getItemLayout</code> props.</p>

Building Mobile Apps with Claude Code: A Game-Changing Development Experience

Accelerating Complex Features</h2>

Getting Started</h2> If you're interested in trying Claude Code for mobile development, here's what I recommend based on my journey from failed attempts to success:</p>

Test with Small Features First</h3> Start with a small project or feature, but make sure it's properly documented. The learning curve is minimal, and the productivity gains become apparent almost immediately when you provide proper context.</p>

A Memorable Family Adventure in Paris

Notes on Rust Programming Language

Rust Programming Language</h1>

Creating Idiomatic use Paths</h4>

Providing New Names with pub use</h4>

Re-exporting Names with pub usee</h4>

Using External Packages</h4>

Using Nested Paths to Clean Up Large use Lists</h4>

The glob operator</h4>

Separating Modules into Different Files</h3>

Summary</h3>

Stoing UTF-8 Encoded Text with Strings</h3>

Storing Keys with Associated Values in Hash Maps-</h3>

Writing Dr Mario game with Bevy

Writing a Chess Engine in Rust with the help of ChatGPT

Ktor Telegram Integration

Ktor Autoreload

Postgres Complexity, Moving to SQLite

Resume

Objective</h1> To secure a software engineering position in a company where my experiences, accomplishments, and proficiency will allow opportunity for growth.</p>

Experience</h1>

Education</h1> M.S Computer Science</em>, 2002 NYU Polytechnic School of Engineering, Brooklyn, NY</p> </li> B.E. Electrical Engineering</em>, 1998 State University of New York at Stony Brook, Stony Brook, NY</p> </li> </ul>

Embracing Docker in my Workflow

My Essential Tools for a Portable Workstation

The Shopping Experience</h1>
Working with dealerships was frustrating. They'd present spec sheets where the numbers didn't add up, sneaking in "market adjustment fees" due to high demand. Most wouldn't budge on price - it was take it or leave it.</p>

Test Drives</h2>
I test drove the Toyota Grand Highlander and Cadillac Escalade. Both had their merits, but neither felt quite right for our needs.</p>

The Decision</h1>
I ultimately chose the 2025 Toyota Sienna XLE. It checked all our practical boxes without the bulk of a full-size SUV.</p>

Final Thoughts</h1>
The biggest lesson? Don't rush. Taking your time is your best negotiating tactic. Dealers can sense desperation, and in a seller's market, patience is your only leverage.</p>

The Car</h1>
2025 Toyota Sienna XLE. Nothing fancy, just practical. It's the perfect blend of space, efficiency, and reliability that our family needs. Sometimes the smartest choice isn't the flashiest one.</p>

Example 1: Mysterious App Crashes</h3>
My app was crashing intermittently on Android. Instead of spending hours adding console.logs everywhere, I just asked Claude Code to analyze the log file. It immediately spotted a memory leak pattern in the logs that I had missed.</p>

Example 2: Performance Optimization</h3>
Claude Code noticed repeated warnings about large lists being rendered without optimization. It not only identified the issue but also suggested implementing `FlatList</code> with proper keyExtractor</code> and getItemLayout</code> props.</p>`

Getting Started</h2>
If you're interested in trying Claude Code for mobile development, here's what I recommend based on my journey from failed attempts to success:</p>

Test with Small Features First</h3>
Start with a small project or feature, but make sure it's properly documented. The learning curve is minimal, and the productivity gains become apparent almost immediately when you provide proper context.</p>

Objective</h1>
To secure a software engineering position in a company where my experiences, accomplishments, and proficiency will allow opportunity for growth.</p>

Education</h1>

M.S Computer Science</em>, 2002 NYU Polytechnic School of Engineering, Brooklyn, NY</p> </li>

B.E. Electrical Engineering</em>, 1998 State University of New York at Stony Brook, Stony Brook, NY</p> </li> </ul>