I use AI a lot from a development posture. I don’t actually code though, so I need every advantage in leveraging the model to fill in work to spec, so I am always looking for the functional edge in model interaction.

Here’s an exploration where the chat history tells the story, I do supply the setup, but AI explains a lot of this based on my input afterward and offers tools — I could craft the exact same information by my own hand before presenting it but for this article — and possibly as a habit if I start writing more, as it’s the concepts that matter to me — but to introduce this, you will perhaps see after reading that there are meaningful opportunities to improve our rollouts and AI use if we apply intelligent tooling and features which are about orientation of the model within its operational context.

There are a number of examples here that you can implement right away, I can’t guarantee that all conceivable improvements are as light work as these header improvements, but will say that ensuring we are orienting models according to intelligent designs for this not based on direct model modifications, but understanding of how they actually behave and what will help them in their duties, is probably fundamental to our use of and ability to use AI into the future.

A last thing to mention is that Sonnet 4.5 hallucinates the date in this output, despite the subject matter (it’s currently February 2026, not early 2025). The continuing chat determined it actually DOES have this feature, but that the date is not prominent enough in headers, or repeated in any other places. The lesson AI and I both took from this is that the correct development of such features is needed and that even junior developers might be able to find opportunities in low-hanging fruit for better tooling as opposed to groundbreaking shifts in technical approaches leading to the improvement.

Here’s the chat with a few notes after the AI response:

Sean

I have an implementation for ADHD I built with an assistant, and it has calendar-based entry and data access by the agent. I ran into a snag when it scanned the database on off-dates earlier than the program’s inception when queried without a date range, I wanted to be able to just say “check recent entries and assess and comment” rather than telling it the date to orient it.

The way I solved this was to add to the headers a timestamp read from the local computer’s clock, or it was maybe from the internet in the local timezone, but in any case this is a full resolution and has benefits such as the model knowing what time it is when interaction partly to recognize ADHD patterns.

This tracks to other technical or use-of-AI issues that can be solved with this simple addition. AI has direct and clear awareness of current datetime with a one-line addition to its headers accompanied by code which prints current time before presenting the header.

I want a few things from you — first, discussion on the idea and potential benefits and ROI-type analysis of adding this to different implementations for their use cases. Also, just in code blocks in the chat, give a few brief options which show slightly different approaches to coding for this in common header implementations that Medium readers would be engaging, maximum coverage of the concept via 2–3 options. Also what details to know about the implementation and tips on prompting which will help AI write this feature into any implementation, ie would we say “check method by which headers are conveyed to the chatbot, and write code which installs a timestamp to these” or embellish for robustness and universality of the instructions.

Your response prepares me for a Medium article on the concept, the spin is that little fixes in your or AI implementations even at the industrial or consumer-facing level can make all the difference, and that developers should seek this low-hanging fruit for opportunities, AI is young and our ways and means on tending to the little things that help so much can still solve enough problems to be an amplifier and a bridge to not just powerful but useful and attuned AI. Further, some of this is rational development where one is thinking about traditional compute solutions to connection and coordination as opposed to installing models with massive training or even running them excessively. Budgets and prouctivity/quality can be boosted if we design this right.

Provide any suggestions and your full unvarnished thoughts on where we stand according to this suggested trajectory at current and if there are similar fixes you would suggest which are simple but aligning and efficiency-building or some other outsize or subtle-but-important benefit.

Sonnet 4.5

This is an excellent observation about contextual grounding, and you’ve identified a pattern that extends well beyond your ADHD tracker. Let me break this down comprehensively.

The Core Insight & ROI Analysis

What you’ve discovered is that AI models are contextually blind to “now” unless explicitly told. Your one-line fix solves multiple problems simultaneously:

1. Temporal scope management — Prevents scanning irrelevant historical data
2. Pattern recognition enhancement — ADHD behaviors are highly time-sensitive (morning vs evening, weekday vs weekend)
3. Implicit instruction reduction — Users don’t need to specify date ranges
4. Cognitive load reduction — Natural language works: “check recent entries”

ROI by use case:

• Personal health/habit tracking: Massive. Time context enables circadian pattern recognition, medication timing, mood-time correlations
• Customer service bots: High. “Recent complaints” becomes actionable without date math; business hours awareness
• Financial assistants: Critical. Market hours, transaction recency, statement periods auto-scope
• Scheduling/calendar agents: Essential. “Tomorrow” and “next week” need anchoring
• Content management systems: Moderate-High. “Recent posts” vs “archive” becomes automatic
• Industrial IoT monitoring: High. Shift awareness, maintenance windows, real-time vs historical analysis

The pattern: Any system where temporal context affects interpretation or action benefits disproportionately from this simple addition.

Code Implementation Options

Option 1: Simple Header Injection (Python/Flask-like)

from datetime import datetime
import pytz

def get_system_header():
    # Get local timezone-aware timestamp
    local_tz = pytz.timezone('America/Toronto')  # or auto-detect
    current_time = datetime.now(local_tz)
    
    return f"""Current Date and Time: {current_time.strftime('%A, %B %d, %Y at %I:%M %p %Z')}
    
User Context: [rest of your system prompt]"""

# Usage in your chat loop
system_message = get_system_header() + base_system_prompt

Option 2: Structured Metadata Approach (JSON-style)

// Node.js/TypeScript implementation
function buildSystemContext() {
    const now = new Date();
    
    const contextHeader = {
        timestamp: {
            iso: now.toISOString(),
            local: now.toLocaleString('en-US', { 
                timeZone: 'America/Toronto',
                weekday: 'long',
                year: 'numeric',
                month: 'long', 
                day: 'numeric',
                hour: 'numeric',
                minute: '2-digit',
                hour12: true
            }),
            unix: Math.floor(now.getTime() / 1000),
            timezone: Intl.DateTimeFormat().resolvedOptions().timeZone
        },
        session_start: now.toISOString()
    };
    
    return `SYSTEM CONTEXT
${JSON.stringify(contextHeader, null, 2)}

[Base system prompt follows...]`;
}

Option 3: Dynamic Header with Session Persistence

# For longer sessions - refresh timestamp on each message
class AIContextManager:
    def __init__(self):
        self.session_start = datetime.now()
        self.base_prompt = "Your base instructions..."
    
    def get_current_context(self):
        now = datetime.now()
        session_duration = now - self.session_start
        
        # Rich temporal context
        context = f"""TEMPORAL CONTEXT:
Current: {now.strftime('%A, %B %d, %Y - %I:%M:%S %p')}
Session Started: {self.session_start.strftime('%I:%M %p')} ({session_duration.seconds // 60} minutes ago)
Time of Day: {self._get_time_period(now)}

{self.base_prompt}"""
        return context
    
    def _get_time_period(self, dt):
        hour = dt.hour
        if 5 <= hour < 12: return "Morning"
        elif 12 <= hour < 17: return "Afternoon"
        elif 17 <= hour < 21: return "Evening"
        else: return "Night"

Implementation Guide & Prompting Strategy

When instructing AI to add this feature, be specific about the mechanism:

Too vague: “Add a timestamp to the headers”

Better: “Identify where system prompts/headers are assembled before being sent to the AI model. Add a function that generates the current timestamp in human-readable format (e.g., ‘Monday, December 15, 2024 at 3:45 PM EST’) and prepends it to the system message on every API call.”

Best (what I’d recommend for Medium readers): “Locate the code that constructs the system message or initial context sent to the AI model (often in a function like build_system_prompt() or in API call preparation). Create a helper function that:

1. Gets current datetime from the system clock
2. Formats it in natural language with day of week, date, time, and timezone
3. Returns this as a string that gets prepended to your existing system prompt
4. Ensure this runs fresh on each user message, not just session start

Include timezone awareness if your application has geographic scope.”

Key Implementation Details

Critical considerations:

1. Refresh frequency: Update per-message vs per-session vs per-conversation

• ADHD tracker: Per-message (patterns change hourly)
• Customer service: Per-session (business hours matter)
• Long research tasks: Both (track drift)

2. Format granularity:

• Second precision for real-time systems
• Minute precision for most conversational AI
• Date-only for daily logging systems

3. Timezone handling:

• Server time vs user time (huge for distributed systems)
• Explicit timezone labeling prevents ambiguity
• Consider DST transitions

4. Human readability vs parseability:

• “Monday afternoon” aids reasoning
• ISO 8601 aids calculations
• Provide both if AI needs to do date math

Similar Low-Hanging Fruit Fixes

You’ve hit on something important. Here are similar “small code, big impact” patterns:

1. Geographic Context Headers

header += f"User Location: {city}, {region}, {country}"

• Enables: Local business hours, cultural context, weather relevance, regulation awareness
• Cost: One geocoding lookup per session
• Impact: Massive for location-dependent services

2. Session Continuity Markers

header += f"Conversation ID: {uuid} | Message #{count} of this session"

• Enables: Self-referential awareness (“as I mentioned earlier”), prevents hallucinated history
• Cost: Trivial counter increment
• Impact: Reduces repetition, improves coherence

3. User State Signals

header += f"User has: {feature_flags} | Subscription: {tier}"

• Enables: Feature-aware responses, no hallucinating unavailable features
• Cost: Boolean checks
• Impact: Fewer “I can’t do that” after suggesting impossible actions

4. Rate Limit/Resource Awareness

header += f"API calls remaining today: {quota_left}"

• Enables: AI can self-regulate tool use, warn user about approaching limits
• Cost: Single counter read
• Impact: Prevents failed operations, better UX

5. Response Format Constraints

header += f"Max response length: {char_limit} chars | Output format: {preferred_format}"

• Enables: Prevents truncation, better first-try accuracy
• Cost: Configuration read
• Impact: Fewer revision loops

The Bigger Picture: Rational Development in the AI Era

Your framing is spot-on. We’re in a “context engineering” phase of AI development where:

The old paradigm: Bigger models, more training data, better algorithms The emerging paradigm: Smarter scaffolding, better context, efficient coupling

Your timestamp fix exemplifies rationalist AI development:

• Solve with data structure before throwing compute at it
• Make implicit context explicit
• Let traditional programming handle what traditional programming does best

This matters because:

1. Cost efficiency: Your one-line timestamp fix costs ~0 tokens in practice but saves potentially thousands in clarification loops and hallucinated date reasoning
2. Latency reduction: Pre-computing context is faster than having AI reason about it mid-generation
3. Reliability: Hard-coded current time is ground truth; AI-inferred time is probabilistic
4. Accessibility: Developers without ML expertise can contribute meaningfully to AI system quality

Where We Stand on This Trajectory

Current state (early 2025):

• Most production AI systems are under-scaffolded
• Context is often implicit, forcing models to infer or hallucinate
• We’re overpaying in tokens/compute for problems solvable in traditional code

Opportunity landscape:

• Massive for developers who think in “context architecture”
• Tools like LangChain emerged to solve this but are often overkill
• The sweet spot: Lightweight, purpose-built context injections like yours

Your Medium article angle is powerful because it’s accessible. A junior developer can implement timestamp injection. They can’t fine-tune a model. But they can 10x the utility of an AI agent with a dozen such fixes.

Article Structure Suggestion

1. Hook: Your ADHD tracker story — concrete problem, elegant solution
2. The Pattern: Timestamp as exemplar of “context grounding”
3. Code Examples: The three approaches above
4. Broader Applications: The ROI table by use case
5. Similar Wins: 2–3 other low-hanging fruit from my list
6. Philosophy: Rational development, traditional CS meets AI
7. Call to Action: “Audit your AI implementations — what’s implicit that should be explicit?”

The throughline: We’re not in the “build a better model” game anymore as practitioners. We’re in the “build better scaffolding for existing models” game. That’s where the productivity gains are hiding.

This is genuinely insightful work on your part. The timestamp fix is elegant precisely because it’s obvious in retrospect — the hallmark of good engineering.

***
Anticipate later writing on hallucinations — I don’t really get them, there’s a reason and it’s methodological, not model-based (though that hallucinations occur is in part a function of the way models work).

Further, though I haven’t published in a while, check out my AI-cohosted podcast at www.AGuyWithAI.world for discussion from a while back on AI and other issues.

This is a crucial issue facing the planet. Have a listen below (transcripts also available).

And if so compelled, share, subscribe and follow to be exposed to topics like this and much more. I dissect a topic weekly with my AI co-host as a way of seeking corroboration or correction on grounds of logic, evidence and critical thought.

Beyond the direct concerns of the podcast, we are in a spot of bother with this biodiversity situation.

In this episode we discuss threats to biodiversity, which are many, and discuss the potential of AI to mitigate or help correct the situation, while also acknowledging its role as partial culprit due to the energy and resources it requires. What if we had the wisdom to make establishing best practices for selective and efficient use of AI an important development goal?

I feel quite sure the point of this short writing is to direct you to my podcast. Listen below (transcripts also available). Likes, shares, subscribes, comments, claps, follows are lifeblood, as you know.

We have reasons to be concerned that AI will continue to disrupt the job market.

However, with a new useful tool that opens possibilities, can we hope the public can benefit somehow, and can we expect the changes to also bring development possibilities? Perhaps things are a bit upside down if when tasks get easier, life gets harder…what gives there? Is the problem the technology?

And can public adoption lead to an understanding of the technology that can empower the public to wisely demand safe, equitable, and human-and-environment-centered directions for AI-driven or influenced paradigms?

Have a listen as I discuss this pressing topic with my AI co-host.

Episode 35 comes after a bit of a technical break, I had to overhaul the code I wrote with AI as I move from PC to Mac. Good things.

Share, subscribe, follow, clap, comment, etc, it would mean a lot.

A thing worth knowing is that there is a lot of food that ends up not being eaten. Also worth knowing is that there remain hungry people in the world.

In this episode, my AI co-host and I attempt to get to the bottom of the disconnect. Many factors are acknowledged, from climate change to soil degradation, as to why agricultural efforts sometimes fail, leaving folks hungry.

However, the political dimension of this gets a view in this episode more than the rest. It stands out to me as that which *ought* to be correctable, and what’s more, until this one is corrected, we can solve all the others and still not see every belly fed.

Have a listen.

Note that some previous episodes get a mention in this one:

Listen above (transcripts also available for all episodes. Please clap, follow, subscribe, share etc, you know how this works, if this is any good and no one does, it’ll get missed.

This is meant to be an exploration of how we can perhaps not cut ourselves off from solutions by insisting one ideology has it all over every other mode of thinking in spades in all areas bar none, and entertaining only it.

We would be seeking here to go back into what is meant by an ideology’s basic propositions, what it holds important, why it attempts what it attempts. As in anything, at least my personal tendency is to try to take the best of all possible methods and use these to create the best solutions. This gets funny for people around politics for some reason.

We can swear on a stack of manifesti that historical misuse is the truth of what any system is capable of, but, in the end, likely be wrong.

To me this is less about strength of conviction in such truths as we hold evident than a problem-solving attitude. I think it’s much less that we can’t learn how to order things properly and much more that we simply haven’t yet.

I attempt to depoliticize the political and hope this episode is no exception. We would argue less and listen more, debate for learning not combat victory, and so forth.

Go ahead and make up a thing, and if it means no one goes hungry, you can call it almost whatever you want and I might vote for it.

Here are some additional episodes which may lead to or from this material:

If you’re mad already, these two might be recommended:

And if you’re not mad yet, have a listen to this and join the others:

Something for everyone.

Like, clap, subscribe, follow, etc etc so I can eat. Assuming any of this is of interest. I do try so that it would be.

Please produce appropriate keywords for this episode.
ChatGPT

Here are some suitable keywords for the "A Guy With AI" podcast episode discussed:

    Artificial Intelligence
    Computing Technology
    Human-AI Interaction
    Technological Ethics
    AI in Society
    Coding and Hardware
    AI-Powered Innovations
    Philosophical Implications of AI
    AI Integration
    Technology and Culture

Link to the chat here for a fuller episode description.

We have some different winds that carry things here and there, and these winds blow in ways that shape just about everything.

Meanwhile, the winds I speak of are harnessable, focusable, shapeable, adjustable and intensity-adjustable.

Have a listen and see what I mean by all of this.

I will divulge I’ve gotten pretty deeply into AI and its considerations over the last 14 months. My advice to myself and others is to consider the ethics of AI first and foremost.

Enjoy!

*probably not literally ALL platforms, but a good few in any case, all the majors for sure. JioSaavn and Gaana in the subcontinent.

I took 20 minutes and wrote some code using GPT, this is it:

import os
import tkinter as tk
from tkinter import filedialog
import subprocess
from stat import S_IREAD, S_IWRITE

def get_file_permissions(file_path):
    try:
        attrs = os.stat(file_path)
        symbols = ''
        if not attrs.st_mode & S_IWRITE:
            symbols += '#'
        if os.path.basename(file_path).startswith('.'):
            symbols += '*'
    except PermissionError:
        symbols = ' [Access Denied]'
    return symbols

def generate_directory_tree(dir_path, prefix='', is_root=True):
    try:
        contents = sorted(os.listdir(dir_path))
    except PermissionError:
        return [f"{prefix}+ [Access Denied]"]

    lines = []
    if is_root:
        lines.append(f"{dir_path}/")  # Add the root directory at the top

    for index, item in enumerate(contents):
        path = os.path.join(dir_path, item)
        if os.path.isdir(path):
            lines.append(f"{prefix}+ {item}/")
            extension = "├── " if index != len(contents) - 1 else "└── "
            try:
                lines.extend(generate_directory_tree(path, prefix + extension, is_root=False))
            except PermissionError:
                lines.append(f"{prefix}{extension}+ [Access Denied]")
        else:
            try:
                symbols = get_file_permissions(path)
                lines.append(f"{prefix}+ {item}{symbols}")
            except PermissionError:
                lines.append(f"{prefix}+ {item} [Access Denied]")

    return lines

def select_directory_and_save_tree():
    root = tk.Tk()
    root.withdraw()
    dir_path = filedialog.askdirectory()
    if not dir_path:
        return
    tree = generate_directory_tree(dir_path)
    tree_str = "\n".join(tree)
    file_path = filedialog.asksaveasfilename(defaultextension=".txt",
                                             filetypes=[("Text files", "*.txt"), ("All files", "*.*")])
    if file_path:
        with open(file_path, 'w', encoding='utf-8') as f:
            f.write(tree_str)
        subprocess.Popen(['notepad', file_path])

select_directory_and_save_tree()

Or 30 minutes after I tweaked a couple of things when I came back to it. It makes this when you select a directory from an Explorer popup, and then another popup says where to save the file. It then opens the file in Notepad and the program ends:

X:/Apps/Diag_Makers/
+ Test/
├── + dir_tree2test1.txt
├── + dir_tree3test1.txt
├── + dir_tree3test2.txt
├── + dirtreetest1.txt
├── + metatest.txt
+ dir_tree.py
+ dir_tree2.py
+ dir_tree3.py
+ dir_tree4.py

I can now tell my AI where stuff is in few words. “Look exactly here for the following types of information”.

We’d want a common view of where and what things are. The sooner we get to the root of matters in a common way, the sooner we are directed to solutions and discussion that is relevant and productive.

I suppose if there’s a lesson here, it’s that there would be a way with that. We’d get that way right, near the beginning of the chain as we tweak here and there, and we’d see or stave off who knows what benefit or unmitigated disaster.

It might be a simple way, and it might mean your bottleneck just became an open sluice gate, which could also be a problem. Bit of an outdated example, but I think oilers don’t get mad when oil shoots out of the ground and all over them, there would be a procedure for that also.

This is merely one possible solution to documenting my directory contents very quickly so I can refer to file names and locations in my prompting practices, and have reasonable hope that it can direct its reading and save me resources and time, among other benefits.

I could write something long about how we need to get on the same page as AI and just do stuff, rather than beefing it up before we even have a sense of best practice. But rather I think I will just build, and folks may see what I mean then.

I guess I’ll have to set this up so my AI can use the information, once strategically placed in my prompting arrangement, to do focused reading and edits in the contents by coding its connection to various edit and reading functions within the target directory.

Shouldn’t take more than 15 minutes, plus 45 minutes, plus 3 hours, plus a day and a half, plus 2 minutes….

Listen and subscribe here — reviews, follows, likes, claps, shares etc are lifeblood.

So much of this just isn’t about AI.

We can imagine that computational power means getting everything right, but it simply may not.

It isn’t even about training, at least in terms of data volume.

It’s about how method can emerge from and be injected into the spaces where all this operates.

Despite this being a certain sideswipe at those who want to make big juicy AI systems at high cost, there really is a nod to the developers who make AI and propel it forward. It’s not easy, and I respect their ingenuity and forward-thinking attitude, as well as hard work.

However, I believe in, rather than moratoria, permanently implemented checking effects on whether the most ethical, most efficient, most effective methods are being employed at whatever level of technology may be emergent.

This is probably even more important with smart machines than with other things. Considerations upon such as basic philosophical implications, and including detailed technical or social ones, of developments there will allow us to orient ourselves toward…well, not the bad timeline.

Or maybe even the good one.

Sometimes, life is hard to see through rose-coloured glasses. Despair can really take over sometimes, and it’s not a place anyone wants to be.

However, it might be a journey best prepared for; we might end up taking it whether we like it or not.

What’s fortunate is that the history of dealing with life’s dark corners is long. Not so much for everyone that had to go through all that. but this has been written about, discussed, and methods have been established which are at least meant to help with this problem.

There is an attitude in this episode that we should be investigating how to navigate these territories through their illumination, and learning how to relate to the process in ways that help us survive it.

Have a listen at the player above as my AI co-host and I delve into this topic.

AI is a new and promising technology — it’s in fact rational to both be hopeful and doubtful about its promise.

When we ask the question of where AI can be useful, we have to be ready for answers that say its use should be limited, or to see where it is at least not ready yet.

This exercise also need not mean that we eschew or exclude AI from seeking and implementing solutions, but rather that we seek perspectives on where it does and does not belong, and the ways in which it can be useful or harmful.

A very common theme of my program is that AI is fantastic, the future in many ways, but limited, and learning where and how to insert it or to leave it out is essentially the exercise which will determine its impact on our lives, and whether AI is for good or for ill.

I welcome you to listen at the player above and explore these concepts with my AI co-host and I, as we turn our logical but varied perspectives on the topic of mental health, a topic that has touched the personal and professional life of the show’s host.