AI evolution in practice: What FileMaker developers are experiencing now and the future

Hardly any other topic is currently changing the IT world as much as artificial intelligence. Just a few years ago, AI systems were considered a distant technology of the future for many small and medium-sized companies. Today, tools such as ChatGPT, local language models, image generators and AI agents are suddenly appearing in everyday working life - often faster than existing processes can even be adapted.

An interesting mixture of enthusiasm, pressure and uncertainty is currently emerging. On the one hand, many entrepreneurs, developers and creatives see enormous opportunities. Texts can be prepared automatically, images generated, data analyzed and processes intelligently supported. At the same time, however, skepticism is also growing. The deeper you delve into the matter, the clearer it becomes that there is often a big difference between an impressive demo and a stable production system.

Especially in the classic Enterprise software this becomes very clear. This is because spectacular individual results alone are not enough. Systems must function reliably, data must remain consistent and processes must be maintainable in the long term. This is precisely where the real challenge of current AI development begins.

Claris announces new AI strategy for FileMaker

Claris has a interesting outlook on the future development of the platform. In the article, Claris CEO Ryan McCann describes how FileMaker will evolve more towards AI-supported development in the coming years.

Particularly exciting is the planned integration of so-called "agentic coding tools". The aim is to make FileMaker a direct development target for modern AI agents. In future, developers will be able to select their preferred AI development tools, formulate requirements in natural language and then transfer the results directly into existing FileMaker solutions. According to Claris, existing security and authorization systems will be automatically retained.

Claris has also announced that AI systems will be able to understand the structure of FileMaker files and the FileMaker scripting language in future. This will enable AI agents to independently generate production-ready scripts and schema extensions directly within existing solutions. It should also be possible to develop modern web interfaces with AI support in the future.

AI systems are often still experimental in practice

Many discussions currently revolve around the visible results: impressive images, fluid texts or autonomous agent systems. However, the practical problems that lie behind them are discussed much less frequently. Interfaces do not function stably, model versions suddenly change, Python dependencies collide with each other or entire training environments break down unexpectedly after updates. Anyone who takes a closer look at local AI systems quickly realizes that the industry is currently still in a very experimental phase.

However, this does not mean that AI is overrated. On the contrary. Artificial intelligence is likely to fundamentally change many areas of software development and company organization, especially in the long term. However, it is crucial to be able to distinguish between short-term hype and sustainable development.

"Evolution of AI" from the perspective of a FileMaker developer

Marcel Moré has written a very interesting article on this topic. In his detailed Article on the "Evolution of AI" he describes very vividly how AI systems are currently developing from simple tools to more complex, increasingly autonomous structures. This is not just about individual language models or image generators, but about the combination of different systems that will increasingly interact with each other in the future.

What is particularly exciting is that Marcel Moré not only focuses on short-term trends, but also views the development as a longer-term technological change. Many of his observations are reminiscent of earlier evolutionary stages in the IT sector. Traditional ERP systems, databases and web platforms have also developed gradually over many years. Initially, they often consisted of individual tools or isolated solutions. Only later did they develop into stable, integrated systems with clear processes and resilient structures.

This is precisely where the topic becomes interesting for FileMaker developers. This is because FileMaker has traditionally always been particularly strong in transforming complex processes into functioning systems pragmatically and comparatively quickly. Many companies have been working successfully for years with customized solutions that are precisely tailored to their own processes. AI now opens up completely new possibilities here - but also brings with it new challenges.

The real question is therefore no longer whether AI will play a role in the future. Rather, the question is how these technologies can be integrated into existing processes in a sensible, stable and economical way. And this is precisely where the exciting transition phase that many developers are currently experiencing begins. While marketing and the media often give the impression that fully automated AI systems are already on the verge of widespread use, everyday life often paints a much more nuanced picture. Many projects are already working surprisingly well in principle - but often only under certain conditions, with considerable technical expertise and sometimes high maintenance costs.

For example, those who use local AIServer or combining different open source systems with each other, you quickly realize how complex these environments have already become. Torch versions, CUDA dependencies, Python environments or different WebUIs can keep even experienced developers busy for days. At the same time, however, it is often during these experimental phases that the experience is gained that later leads to truly stable solutions.

Perhaps this is exactly what reminds many experienced developers of earlier times in IT. Even then, many long-lasting systems were not created through perfect, glossy concepts, but through years of trial and error, adaptation and gradual improvement. This is precisely why it is worthwhile neither being blindly euphoric nor prematurely dismissive of current AI developments. Those who take the technological possibilities seriously, but at the same time understand the practical limitations, are likely to be in a much better position in the coming years than those who merely chase short-term trends.

The view from the outside: What developers are really observing at the moment

If you only follow current AI developments via headlines or social media, you quickly get the impression that artificial intelligence is already on the verge of completely taking over entire areas of work. In practice, however, many developers have a much more nuanced view of the situation. In fact, it is not so much the individual AI itself that is currently changing - but rather the way in which different systems are combined with each other.

Just a few years ago, many AI applications consisted of individual specialized tools. One system generated texts, another images, yet another analyzed data or transcribed speech. Now, however, a new generation of AI environments is increasingly emerging in which several models work together in parallel and complement each other.

Marcel Moré describes precisely this development very clearly in his article. AI is developing step by step from individual functions to networked systems with their own processes. This not only changes the technical architecture, but also the role of the developers themselves.

This is because developers today are increasingly no longer programming every single function completely by hand. Instead, they orchestrate systems, models, interfaces and automations with each other.

AI agents and automated processes

This development is currently particularly visible in so-called AI agents. This refers to systems that no longer just answer individual commands, but are able to carry out several steps independently one after the other. An AI agent could, for example:

• Research information,
• Analyze data,
• Summarize contents,
• Ask questions,
• Save results
• and then automatically trigger further processes.

From a technical point of view, this is already partly reminiscent of classic workflow systems or ERP processes - only much more flexible and dynamic.

Developers in particular quickly recognize the opportunities here, but also the risks. Of course, such systems seem impressive at first glance. At the same time, however, the question immediately arises as to how stable and controllable these processes will actually remain in the long term. A classic ERP system normally works on the basis of strict rules. AI systems, on the other hand, react probabilistically, i.e. based on probabilities. This is precisely where new challenges arise.

When a classic Script in FileMaker is faulty, the error can usually be narrowed down relatively clearly. This is much more difficult with complex AI systems. Here, errors are often not caused by a single programming error, but by interactions between models, prompts, data quality or external interfaces.

The real challenge: integration instead of AI

Many developers are therefore now realizing that the actual difficulty is often no longer in the AI model itself. The models are becoming increasingly powerful and easier to use. The real problems often only arise when integrating them into existing systems. Companies in particular often have evolved data structures, older software solutions, different data sources, individual processes and numerous special cases.

And this is exactly where it becomes clear whether an AI solution is really suitable for everyday use. Because an impressive demo can be created quickly. A permanently stable system, on the other hand, requires clean data, clear workflows, controllable processes, traceable results and long-term maintainability.

Many experienced developers are therefore currently observing an interesting shift. While the public often talks about ever larger models, companies are increasingly concerned with completely different issues:

• How do we integrate AI sensibly?
• Which processes are suitable at all?
• Where does AI really save time?
• What risks arise?
• And how does the system remain maintainable?

These questions seem less spectacular - but are probably much more important.

Why FileMaker developers in particular have interesting advantages here

This development could be particularly exciting in the FileMaker environment. This is because many FileMaker developers have been used to developing pragmatic solutions for real business processes for years. Instead of purely theoretical architectures, the focus is often on concrete processes:

• Orders,
• Customer management,
• Bearing,
• Documents,
• Workflows,
• Interfaces
• or individual special processes.

It is precisely this practical experience that could be a major advantage in the future. After all, AI alone does not solve organizational problems. If data is structured chaotically or processes have never been clearly defined, even the best AI will not turn it into a stable system.

Many developers are even realizing that classic software principles are suddenly becoming more important again:

• clean data models,
• clear relationships,
• traceable processes,
• Stable interfaces
• and structured data maintenance.

Interestingly, this is partly reminiscent of earlier development phases of the Digitization. Even back then, many companies initially believed that new technologies would solve existing problems almost automatically. In reality, however, it almost always turned out that sustainable systems were created primarily through good structures.

Between an experimental phase and long-term change

At the same time, however, many developers also feel that the current AI wave will not simply disappear again. The technology is developing too quickly for that. Just two years ago, many AI systems seemed more like interesting experiments. Today, complete workflows are already being created around language models, image generators or automation processes. Even smaller companies are increasingly starting to test how AI can be put to good use.

However, this also reveals a typical pattern of technological upheaval. Initially, people often overestimate what is possible in the short term. At the same time, the extent to which technologies will actually change in the long term is underestimated. This is precisely why many developers are observing the current situation with a mixture of enthusiasm and caution.

On the one hand, fascinating opportunities are currently emerging. On the other hand, it remains to be seen which platforms, models and working methods will establish themselves in the long term. Many of today's solutions are likely to have disappeared or been completely replaced in just a few years.

This makes a calm, pragmatic approach all the more important. Not every new AI tool needs to be used productively immediately. At the same time, however, it would probably be a mistake to ignore development altogether. Those who get to grips with the basics early on, gain practical experience and classify the systems realistically are likely to be much better prepared in the long term.

And it is precisely at this point that the really exciting phase of AI evolution begins for many developers.

The reality of everyday life: why AI projects are often much more complicated than expected

Anyone who takes a closer look at artificial intelligence quickly realizes that there is a considerable difference between a functioning demonstration and a stable everyday system. It is precisely at this point that many companies and developers become disillusioned. After all, the possibilities of modern AI systems are impressive. Language models write texts, analyze data or answer complex questions in seconds. Image generators produce content that would have been technically unthinkable just a few years ago. At the same time, however, the impression often arises that these systems now only need to "connect somehow" in order to automatically create productive business solutions.

In practice, however, it quickly becomes apparent that this last step is often the most difficult. This is because real company processes rarely consist of simple standard procedures. Data comes from different sources, structures have grown historically and many special cases have been individually adapted over the years. This is where the real work begins.

The invisible side of AI projects

From the outside, many AI projects often appear surprisingly sleek and modern. Functioning results, elegant user interfaces or short demonstrations of impressive functions are presented. However, the many hours of troubleshooting and maintenance work behind such systems are much less visible. Developers in particular are currently experiencing similar situations time and time again:

• A model suddenly stops working after an update,
• Python dependencies collide,
• CUDA versions do not match,
• Interfaces change,
• Memory problems occur,
• or individual extensions make entire environments unstable.

This dynamic is particularly evident in the open source sector. Many tools are developing extremely quickly. New functions sometimes appear every week. At the same time, there is often a lack of long-term stable standards. As a result, developers quickly find themselves in a kind of permanent maintenance mode. It is not uncommon for them to spend more time getting systems up and running again than actually working productively with them.

Why maintainability is suddenly becoming a key factor again

Experienced developers in particular are therefore currently recognizing an interesting development: many classic principles of professional software development are suddenly gaining enormous importance again. After all, even the most modern AI is of little use if the overall system becomes unstable. Companies don't need spectacular individual demos, but:

• traceable processes,
• reproducible results,
• stable interfaces,
• controllable data flows
• and long-term maintainability.

However, this is often the greatest weakness of current AI projects. Many systems are currently being developed on an experimental basis. Different tools are combined with each other, new extensions are tested and different models are used in parallel. This often works surprisingly well in the short term - but quickly creates complex dependencies in the long term.

This is particularly critical for productive business solutions. This is because it is not enough for a system to work "most of the time". Processes must run reliably - even after updates, server changes or personnel changes. Many developers are therefore currently remembering earlier IT principles:

• prefer stable solutions to short-term gimmicks,
• We prefer comprehensible processes to maximum complexity,
• I prefer maintainable systems to impressive individual tricks.

Interestingly, this development almost seems like a return to the classic virtues of software development.

The real work often only begins after the first success

Another problem with many AI projects only becomes apparent after the first positive results. Initially, many things work surprisingly quickly:

• The first image generators are running,
• Texts are generated,
• Automations arise,
• local models get off to a successful start.

But this is exactly when the difficult phase often begins. Suddenly questions arise such as:

• How do we secure the environment?
• Which model version do we use permanently?
• How do we document the processes?
• How scalable is the system?
• How do we prevent data chaos?
• Who will wait for it later?

Smaller companies in particular often significantly underestimate this effort. While traditional software can often be operated relatively stably for years, many AI systems are currently still in a very dynamic development phase. Models, libraries and frameworks sometimes change so quickly that long-term planning becomes difficult. This is precisely why many developers are currently reporting unusually high maintenance costs.

Our own practical experience

This becomes particularly clear with local AI servers and training systems. Anyone who sets up such environments themselves quickly realizes how many small technical details have to work together:

• Graphics card driver,
• Torch versions,
• CUDA support,
• Python environments,
• Extensions,
• WebUIs,
• Memory management
• and model compatibility.

A single incompatible version is often enough for a previously functioning system to suddenly fail completely. However, these experiences also make it clear why many current AI discussions sometimes seem somewhat unrealistic. From the outside, the impression is often created that modern AI systems are already largely mature. In practice, however, it quickly becomes apparent that many areas are still highly experimental.

However, this does not mean that this development will fail. On the contrary. We are probably currently in a typical transition phase for new technologies. Early web servers, database systems and ERP solutions were also often complicated, unstable and high-maintenance at first. Only over time did they develop into standardized and resilient platforms.

This is precisely why the current phase is likely to be extremely important in the long term. Because it is precisely now that developers are gaining the practical experience that will later give rise to stable structures.

Why pragmatism is currently more important than perfection

Many experienced developers are therefore now taking a much more pragmatic approach. Not every new model has to be integrated immediately. Not every technical innovation automatically brings real added value. It often makes more sense to work with smaller, stable solutions and expand them step by step. In the long term, companies in particular usually benefit more from clear processes, manageable systems, a clean data structure and controllable automation.

The real strength of artificial intelligence could therefore ultimately lie less in spectacular individual actions and more in intelligently supplementing existing processes and gradually making them more efficient. And this is probably exactly where the success of AI projects will be decided in the long term: not with the biggest demo, but with the permanently stable practical solution.

Parallels to classic software development

If you take a more sober look at the current development of artificial intelligence, you will notice an interesting parallel: Many challenges are surprisingly reminiscent of earlier phases of classic software development.

Because there, too, many things initially began with great euphoria. New technologies promised faster processes, lower costs and completely new possibilities. At the same time, however, it almost always turned out in practice that sustainable systems were not created through technical innovation alone, but above all through clean structures, clear processes and long-term maintainability.

It is precisely this development that currently seems to be repeating itself in a similar form in the field of AI. At present, many discussions still focus heavily on the visible capabilities of modern AI systems:

• better language models,
• larger context window,
• faster image generators,
• autonomous agent systems
• or complex automation.

But the deeper companies and developers get into real projects, the clearer it becomes that the same basic questions arise here as before:

• How stable is the system?
• How maintainable is the solution?
• How clean is the data?
• How reliable are processes?
• And how dependent are you on individual platforms?

Even classic ERP systems were not created overnight

Developers with many years of experience in particular will therefore recognize many familiar patterns. Even classic ERP or database systems were often much more chaotic and experimental in the beginning than you might expect today. Many solutions were developed step by step:

1. individual functions first,
2. then smaller automations,
3. later more complex processes,
4. Finally, integrated overall systems.

Stable solutions often only developed after many years of practical experience. FileMaker in particular was an interesting tool for many companies because processes could be mapped comparatively pragmatically and quickly. Instead of huge theoretical concepts, concrete solutions for real problems were often developed:

• Order management,
• Warehouse management,
• Document processes,
• Customer management
• or individual industry solutions.

It is precisely this practical way of thinking that could now become more important again in the field of AI. After all, artificial intelligence does not replace poorly organized processes. If data is chaotically structured or processes have never been clearly defined, AI often creates additional sources of error rather than real improvements.

Why data structures are suddenly becoming crucial again

Interestingly, the current AI wave is even causing many classic IT principles to take center stage again. Although modern AI systems are often flexible and intelligent, they remain heavily dependent on the quality of the underlying data. This applies to

• Master data,
• Document structures,
• Keywording,
• Relationships,
• Process definitions
• and data consistency.

This is where a problem often becomes apparent that many companies have suppressed for years: Historically grown systems often contain inconsistencies, special cases and unclear structures.

Such problems cannot simply be "intelligentized away" by AI. On the contrary. Faulty data structures are often even reinforced because AI systems recognize patterns and process them further - regardless of whether these patterns are useful or problematic.

Many developers are therefore currently realizing that good data maintenance is suddenly gaining enormous importance again. This is reminiscent of earlier database projects, where long-term success often depended less on spectacular functions and more on:

• clean data model,
• clear relationships,
• traceable processes
• and disciplined structuring.

The danger of the new "quick fixes"

Another parallel to classic software development can be seen in the topic of quick fixes. Even in earlier IT phases, tools were repeatedly created that seemed impressive in the short term, but caused considerable problems in the long term. Many developers still remember this well:

• overloaded Access solutions,
• unstructured Excel systems,
• poorly documented scripts,
• or hastily clicked together web applications.

Initially, such systems often worked surprisingly well. It was only later that maintenance problems, data chaos or dependencies that were difficult to control arose. Precisely similar risks are now emerging again in the AI sector. Many current AI workflows consist of a large number of combined tools:

• different models,
• external APIs,
• Plugins,
• local servers,
• Automations,
• Prompt chains
• and experimental extensions.

In the short term, this produces impressive results. In the long term, however, the question arises as to how stable and maintainable such constructions actually remain. Experienced developers in particular are therefore currently observing with a certain degree of caution how quickly some companies are attempting to use complex AI processes productively, even though fundamental organizational issues are often still unresolved.

Why long-term thinking is particularly important now

This is precisely why the current phase is likely to reward those developers and companies who think long-term. Not every new function has to be integrated immediately. Not every trend tool will remain relevant in the long term. Many of today's systems are likely to disappear or be completely replaced within a few years.

However, the real strength of professional software development has always been to create stable foundations. And it is precisely this ability that is likely to remain crucial in the age of AI:

• Understanding processes,
• Structuring systems,
• Organize data cleanly,
• Document processes
• and technical complexity manageable.

There is no doubt that artificial intelligence is currently changing the world of software. At the same time, however, it also shows that many basic principles of good IT work have remained timeless. Perhaps this is precisely the most important insight of current AI development: not everything is completely new. Rather, many things are evolving as the next stage in the evolution of already known principles.

Where AI really makes sense today - and where the journey with FileMaker could take us

After the first big AI waves, a much more sober view of the topic is slowly emerging. Many companies and developers are now realizing that artificial intelligence is neither a short-term magic trick nor a mere gimmick. At the same time, however, it is also becoming clear that not every task can be meaningfully automated.

Particularly in day-to-day business, it is not so much the most spectacular demo that is decisive in the end, but rather the practical suitability for everyday use. And this is precisely where a number of areas are now emerging in which AI can already deliver real added value.

Text generation as the first major productive area

The benefits are probably most visible in word processing. Language models can now:

• Prepare documents,
• Formulate e-mails,
• Create summaries,
• Generate translations,
• Prepare FAQ areas
• or generate structured content from raw data.

This is where enormous time savings are already being made. What is particularly interesting is that AI often does not completely replace humans, but rather functions as an intelligent assistant. Many developers, editors and entrepreneurs now use AI in a similar way to an additional employee for preparatory work, structuring or collecting ideas.

However, this does not mean that results should be accepted without checking. Control remains crucial, especially when it comes to technical or legal issues. Nevertheless, this area is likely to remain one of the most important practical areas of application in the long term. This will be particularly exciting where existing company data can be used directly - for example:

• automatic quotation templates,
• E-mail responses,
• Documentaries,
• Knowledge databases
• or internal assistance systems.
• AI as support instead of a complete replacement

Another realistic area of application currently lies in supportive assistance functions. Many companies are now realizing that AI works particularly well where it complements people rather than replacing them completely. These include, for example:

• intelligent search functions,
• automatic categorization,
• Data analysis,
• Image classification,
• Document recognition
• or proposal systems.

This could be particularly interesting in the ERP and database environment in the long term. This is because large volumes of structured information are generated there every day:

• Invoices,
• Documents,
• Customer inquiries,
• Storage data,
• Product information
• or e-mail communication.

AI can help to evaluate such information more quickly, organize it sensibly or prepare processes. However, the actual decision-making process often remains with humans. It is precisely this hybrid approach that is likely to be much more realistic for many companies than the idea of fully autonomous AI systems.

Why automation alone is not enough

Interestingly, however, many AI projects are currently reaching their limits. After all, technically automatable does not automatically mean organizationally sensible. Companies in particular have numerous processes that contain exceptions, require human communication, demand responsibility or need to be kept deliberately flexible.

Many developers now realize that artificial intelligence does not simply replace traditional software. Instead, a new level of intelligent support is emerging on top of existing systems. This is somewhat reminiscent of earlier digitalization steps. Even then, processes did not simply disappear completely. Instead, they gradually became more efficient, more structured and better supported.

It is precisely this pragmatic view that is likely to be more important in the long term than the idea of a completely autonomous corporate AI.

Particularly exciting: AI directly within FileMaker

However, this development could become particularly interesting in the FileMaker environment in the coming years. This is because Claris FileMaker has already announced that it will increasingly rely on so-called AI agents in the future. This is no longer just about classic AI queries or external interfaces, but about systems that can actively work directly within FileMaker.

And this could significantly change the way many developers work in the long term. Until now, AI support has been relatively indirect in many cases:

• Developers formulate prompts,
• receive text suggestions,
• copy scripts,
• customize code manually
• and integrate the results into the solution themselves.

However, the announced agent systems go one step further. In future, developers will increasingly be able to formulate tasks directly in natural language:

• create new tables,
• Generate scripts,
• Prepare layouts,
• Create relationships,
• Complete fields
• or automate processes.

The AI would then not only provide suggestions, but would actually work actively within the FileMaker environment.

Why this could change software development

If this development becomes stable and controllable, it would have a significant impact on day-to-day development work. Because suddenly the focus shifts:

Away from pure technical implementation, towards process description and system logic.

Interestingly, this is somewhat reminiscent of the original strength of FileMaker itself. FileMaker was always particularly attractive because many processes could be implemented comparatively quickly and visually. Developers had to do less "low-level programming" than in classic development environments.

AI agents could now take this approach to a new level. Instead of manually programming individual scripts, developers could in future work more as:

• System architects,
• Process designer,
• Data modeler
• and quality controllers.

The actual technical implementation would be increasingly automated.

At the same time, completely new challenges are emerging

Nevertheless, this development is unlikely to run completely smoothly. Because as soon as AI can make changes directly within productive systems, issues such as:

• Control,
• Traceability,
• Versioning,
• Authorizations
• and quality assurance

even more important. Experienced developers in particular will probably pay very close attention to how reliably such agents actually work. After all, an incorrectly generated script or a faulty structural change can have considerable consequences in productive database systems.

Human control will therefore probably remain central in the long term. The real strength of such systems could lie less in completely replacing developers, but rather in massively accelerating repetitive work and being able to prepare complex processes more quickly.

Probably the most realistic way to develop AI

This could also be the most realistic future for artificial intelligence overall. Not in fully autonomous systems that completely replace humans. But rather in intelligent tools that accelerate processes, structure information, reduce repetitive work and support people in complex tasks.

FileMaker in particular could remain an interesting platform for this in the long term because it allows traditional business processes to be combined with new AI functions in a comparatively flexible way. And perhaps this is where the actual direction of AI evolution is already evident today:

not the complete replacement of existing systems - but their gradual intelligent expansion.

Our own practical experience: between the experimental phase and a productive future

Anyone who seriously wants to integrate artificial intelligence into existing systems today quickly realizes that many public discussions only show a small part of the actual reality. This is because while spectacular results are often visible to the outside world, the actual day-to-day reality often consists of numerous small technical, organizational and structural challenges.

This is precisely the experience of many developers who are currently trying not only to use AI systems for testing purposes, but also to integrate them productively into their own workflows. It quickly becomes clear that artificial intelligence is not so much a finished product at the moment, but rather a new technological construction site with enormous potential.

Building your own AI infrastructure instead of using the cloud alone

The topic becomes particularly interesting when developers start to set up their own AI infrastructures. While many users only use cloud-based tools, local systems are increasingly being created in parallel:

• own Linux AI server,
• local language models,
• Image generators,
• Training environments
• or combined workflow systems.

This opens up completely new possibilities, especially in creative and technical environments. However, it quickly becomes clear how complex these environments have already become. Anyone setting up their own Linux-based AI image servers, working with local models or combining different systems, for example, is often operating in an environment that is still highly experimental in nature.

Drivers, CUDA versions, torch dependencies, memory management or incompatible extensions can keep even experienced developers busy for days. Many problems do not arise from single major errors, but from countless small technical dependencies. Nevertheless, it is often in this phase that the real practical experience is gained.

Control AI directly from FileMaker

However, the topic becomes particularly exciting when traditional business software is combined with modern AI systems. This is precisely where interesting new approaches are currently emerging. In practice, various AI systems can already be controlled directly from FileMaker:

• Text models,
• Image generators,
• Model administrations,
• Prompt systems,
• Server controls
• or automated transfer routines.

Increasingly specialized administration interfaces are being created via which:

• Models organized,
• Server managed,
• Prompt templates saved,
• JSON structures prepared
• and various AI processes can be controlled centrally.

Interestingly, this is partly reminiscent of classic ERP development - except that instead of warehouse data or invoices, AI models, prompts and training parameters are suddenly being managed. The combination of structured database logic and flexible AI systems in particular is likely to have enormous potential in the long term.

The current limit: AI understands a lot - but is not yet integrated cleanly enough

Despite all the progress made, however, there is still an important limit. This is because modern language models are already amazingly good:

• Generate scripts,
• Write formulas,
• Explain database structures
• or prepare complex logic.

However, the actual integration into productive FileMaker solutions is often still relatively manual. In concrete terms, this means

• Code must be adapted,
• Scripts are transferred,
• Structures controlled,
• Formatting corrected
• and processes are checked manually.

This poses a particular problem in the FileMaker environment. This is because FileMaker scripts have their own internal structure and cannot simply be transferred directly into the script editor as normal text. This currently results in various intermediate solutions:

• manual transfer,
• XSLT conversions,
• Clipboard converter,
• special copy & paste tools
• or conversion systems for FileMaker-compatible script formats.

This is already working surprisingly well in everyday life - but at the same time it still looks like a transitional phase between classic development and future AI integration.

This is precisely where AI agents could close the crucial gap

And this is precisely where the agent technology announced by Claris FileMaker becomes particularly interesting. Until now, there has often been a kind of "manual translation layer" between AI and productive development. The AI generates content, suggestions or scripts - the developer then takes over the actual technical integration.

AI agents could significantly reduce this gap in the future. Because if AI systems can work directly within FileMaker, the entire way of working will change:

• Scripts could be generated directly,
• tables are created automatically,
• relationships,
• Layouts prepared
• or processes can be expanded dynamically.

The developer would then carry out fewer individual technical steps himself, but more:

• Describe processes,
• Define logic,
• Check results
• and structure systems.

This could lead to a considerable leap in productivity in the long term.

Why experienced developers in particular could benefit from this

Interestingly, this development is likely to benefit experienced developers in particular. Although AI can increasingly take on technical tasks, it does not automatically understand the actual business processes behind them. This remains crucial, especially for more complex solutions:

• Process understanding,
• Data logic,
• Experience with special cases,
• organizational thinking
• and long-term structural planning.

Many companies still underestimate just how important these skills could become in the future. After all, if standard technical tasks are increasingly automated, the actual value will shift more towards them:

• Architecture,
• Consulting,
• Process design
• and quality control.

FileMaker developers in particular often have an interesting advantage because they traditionally work very closely with real business processes.

Between today's experimental phase and future productive environment

Of course, this development is still at a relatively early stage. Many systems still seem experimental, sometimes unstable or organizationally unfinished. At the same time, however, it is already possible to see where the direction could go. Just a few years ago, local language models, AI image servers or agent-based development systems seemed almost like dreams of the future. Today, the first productive approaches already exist, which are surprisingly efficient despite all the difficulties.

This is precisely why the current phase is likely to be particularly exciting in the long term. After all, the foundations for a new generation of development tools are probably being laid right now - similar to the first graphical database systems or early ERP platforms.

And perhaps in a few years' time, we will look back and realize that this current transition phase was precisely the moment when classic software development slowly shifted towards AI-supported system development.

AI evolution does not mean the end of traditional development - but its next stage

After the first few years of great AI euphoria, a more differentiated picture is slowly beginning to emerge. Many companies, developers and creatives are increasingly recognizing that artificial intelligence is neither a short-term trend nor an immediate all-in-one solution for all problems.

At the same time, however, it is becoming increasingly clear that technological developments are likely to have a significant impact on the entire software world in the long term. An interesting double movement is currently taking place: On the one hand, new tools, models and automation are emerging every day. On the other hand, many classic principles of professional software development are suddenly gaining importance again:

• clean data structures,
• traceable processes,
• Maintainability,
• Stability
• and organizational thinking.

This is precisely why the current AI phase in many respects seems less like a complete break with the previous IT world - and more like its next evolutionary stage.

The real challenge does not lie in the AI itself

Interestingly, many projects now show that the actual difficulty is often no longer the AI model itself. Modern language models, image generators and assistance systems already work amazingly well today. The real challenges usually only arise where these systems are to be meaningfully integrated into real business processes. This is precisely where new technologies come into play:

• grown structures,
• historical databases,
• Individual processes
• and practical requirements of everyday life.

Many developers are therefore currently experiencing a phase of intensive experimentation. Systems are being tested, local servers set up, models integrated and processes automated. At the same time, however, it is also becoming clear that productive stability requires much more than impressive individual demos.

In the long term, therefore, solutions that combine technical possibilities with pragmatic suitability for everyday use are likely to be particularly successful.

Why practical experience is currently becoming particularly valuable

It is precisely at this point that practical experience becomes increasingly important. Because anyone actively working with local AI systems today, setting up their own environments or combining AI directly with company software will recognize the actual opportunities and limits of current developments relatively quickly.

This often results in much more realistic assessments than in many public discussions. Artificial intelligence can already provide enormous support today:

• for word processing,
• Knowledge organization,
• Data analysis,
• Automation
• or creative processes.

At the same time, however, it remains clear that many systems are still highly experimental at the moment. This is precisely why the current phase is likely to be particularly valuable in the long term for those who gain practical experience early on while maintaining a sober perspective.

Marcel Moré's view of the evolution of AI

Marcel Moré's article on the "Evolution of AI" was an interesting starting point for these considerations. What is particularly exciting about this is not so much the individual technology, but rather the fundamental observation: AI is increasingly developing from isolated tools into networked systems with their own processes, automation and agent-like structures.

It is precisely this development that is likely to shape the coming years. In the long term, it will probably no longer just be about individual language models or image generators, but about complete system landscapes in which different AI components interact with each other.

Especially in the corporate environment, this creates enormous potential - but also new organizational and technical challenges.

FileMaker and the next stage of development

This development could be particularly interesting in the Claris FileMaker environment in the future. This is because the announced AI agents already indicate where modern development environments could be heading in the long term:

• away from purely manual implementation,
• towards AI-supported system development.

Should such agent systems be able to work stably within FileMaker in the future, the role of many developers would change significantly.

The actual strength would then presumably lie less in the pure writing of individual scripts, but more in:

• Process understanding,
• System architecture,
• Data logic,
• Quality control
• and organizational thinking.

Interestingly, this fits in very well with the traditional strengths of many FileMaker developers. FileMaker has always been particularly strong at mapping real business processes pragmatically and flexibly. AI could significantly expand this approach in the future.

Probably the most important finding of the current AI phase

Perhaps this is precisely the most important insight of the current development. Artificial intelligence does not automatically replace experience, structure or organizational thinking. Rather, new tools are currently being created that can intelligently expand and accelerate existing ways of working.

The real challenge is therefore probably not to adopt every new AI function as quickly as possible. Rather, the decisive factor will be:

• which systems remain stable in the long term,
• which processes can really be automated in a meaningful way
• and how technical possibilities can be integrated responsibly.

Developers with practical background knowledge in particular are likely to play an important role in the future. Because in the end - as is so often the case in IT history - it will probably not be the loudest demo that wins out, but the solution that works permanently in everyday life.

---

Frequently asked questions

1. Why is there currently the impression that artificial intelligence is suddenly appearing everywhere at the same time?
   Development has picked up speed massively in the last two years. In the past, AI systems were often special solutions for large corporations or research institutions. Today, language models, image generators and automation tools are suddenly available to almost everyone. This is having a similar effect to the advent of the internet or, later, smartphones: many companies are realizing at the same time that work processes could change fundamentally.
2. Why are public AI presentations often so different from everyday practice?
   Presentations usually show controlled scenarios that work under ideal conditions. In reality, however, AI systems have to deal with faulty data, individual special cases, old software structures and unstable interfaces. This is precisely where the real challenges arise, which are often barely visible to the outside world.
3. Why is the maintenance of AI systems currently so costly?
   Many AI environments are still in a very dynamic development phase. Models, extensions, Python dependencies and interfaces sometimes change on a weekly basis. Even small updates can make functioning systems unstable. Developers therefore often spend a surprising amount of time getting environments up and running again.
4. What role do local AI servers play in the corporate environment?
   Local AI systems are becoming increasingly interesting for many companies because they allow more control over data, models and processes. A local infrastructure can offer advantages, especially for sensitive information or specialized workflows. At the same time, however, this also increases the technical effort considerably.
5. Why are many current AI problems reminiscent of earlier IT development phases?
   Early web servers, ERP systems and database platforms also often seemed complicated and unstable at first. It took many years for standardized and resilient systems to emerge. Many experienced developers currently recognize similar patterns in the AI sector and therefore view the current phase more as a long-term development process.
6. Why is data quality suddenly becoming so important again thanks to AI?
   AI systems work on the basis of existing information. If data is chaotically structured, incorrect or incomplete, the AI still recognizes patterns and processes them further. Bad data therefore often leads to bad results. This is precisely why clean data structures and clear processes are becoming more important again.
7. Why could FileMaker harmonize particularly well with AI in the long term?
   FileMaker has always been designed to map real business processes in a pragmatic way. It is precisely this flexibility that suits modern AI systems very well. While traditional development environments are often very technical, FileMaker is particularly well suited to quickly adapting processes and combining them with new technologies.
8. What exactly are AI agents?
   AI agents go far beyond traditional chatbots. They not only answer questions, but also independently carry out several work steps in succession. These include analyses, process control, data processing or automated decisions within defined processes.
9. Why are the announced AI agents from Claris so interesting for FileMaker developers?
   Because this could change the way software is developed. In future, developers may no longer have to program every single technical step themselves. Instead, processes could increasingly be described in natural language, while the AI prepares the technical implementation or takes over some of it directly.
10. How does AI-supported development in FileMaker usually work today?
    Currently, a lot of things still work semi-manually. Developers create scripts, formulas or structures with the help of AI systems and then transfer them to FileMaker themselves. There are now various auxiliary solutions for this, such as clipboard converters or special conversion tools.
11. Why is the direct transfer of AI-generated code to FileMaker still complicated at the moment?
    FileMaker has its own internal script structures that cannot simply be inserted like normal text. For this reason, AI outputs often have to be adapted or converted using special intermediate solutions before they can be used productively.
12. Which practical areas of application for AI are already working particularly well today?
    AI is already delivering very useful results, particularly in text generation, document recognition, translations, knowledge organization, data analysis and supporting automation. AI is particularly strong where repetitive tasks can be prepared or accelerated.
13. Why is artificial intelligence unlikely to completely replace traditional developers?
    Because technical implementation is only one part of professional software development. Process understanding, data logic, organizational processes and long-term structural planning remain crucial. AI can speed up many tasks, but it does not automatically understand the full complexity of real companies.
14. Why could the role of developers nevertheless change significantly?
    The focus is likely to shift increasingly - away from simply writing technical routines and towards system architecture, process design, quality control and strategic planning. As a result, developers are likely to become more organizational and technical overall planners.
15. Why are many companies currently overestimating the speed of AI development?
    Because visible progress often happens faster than stable production systems are actually created. There are often many months or even years of practical development work between an impressive demo and a resilient everyday system.
16. What is the danger of rushed AI projects?
    Many companies run the risk of confusing short-term experiments with long-term stable solutions. Without clear data structures, comprehensible processes and maintenance concepts, unstable systems quickly emerge, which later cause high follow-up costs.
17. Why are developers currently gaining so much practical experience with Linux AI servers?
    Because local systems allow more control and flexibility. Developers can use their own models, carry out specialized training and combine different tools. At the same time, however, this also creates many technical challenges that currently still require a lot of experience and patience.
18. Why might the current phase of AI development be particularly important in retrospect?
    The foundations for future standard systems are probably being laid right now. Many of today's experiments may still seem unfinished or complicated, but they provide valuable practical experience. Earlier technological upheavals in the history of IT were similar.
19. What is likely to determine the success of AI projects in the long term?
    Probably not the most spectacular individual technology, but the ability to build stable, maintainable systems that are suitable for everyday use. In the long term, solutions that support real business processes in a meaningful way and function reliably over the long term will probably be the most successful.