Skeet: Towards a Lightweight Serverless Framework Supporting

Modern AI-Driven App Development

Kawasaki Fumitake, Shota Kishi and James Neve

ELSOUL LABO B.V., Amsterdam, Netherlands

Keywords:

Framework, AI, Typescript, Serverless.

Abstract:

The ﬁeld of web and mobile software frameworks is relatively mature, with a large variety of tools in different

languages that facilitate traditional app development where data in a relational database is displayed and mod-

iﬁed. Our position is that many current frameworks became popular during single server deployment of MVC

architecture apps, and do not facilitate modern aspects of app development such as cloud computing and the

incorporation of emerging technologies such as AI. We present a novel framework which accomplishes these

purposes, Skeet, which was recently released to general use, alongside an initial evaluation. Skeet provides

an app structure that reﬂects current trends in architecture, and tool suites that allow developers with minimal

knowledge of AI internals to easily incorporate such technologies into their apps and deploy them.

1 INTRODUCTION

The use of artiﬁcial intelligence (AI)-based technolo-

gies has rapidly expanded in recent years (Makri-

dakis, 2017). Where AI was previously a useful but

relatively niche technology used for extracting infor-

mation from large datasets, it has recently been more

broadly incorporated into a variety of existing tech-

nologies, from self-driving cars (Badue et al., 2021) to

healthcare (Hamet and Tremblay, 2017). The technol-

ogy is also easier for non-specialist software develop-

ers to access, with companies such as Google offering

pre-trained models via Google Cloud Platform (GCP)

which allow the incorporation of AI-driven technolo-

gies without requiring speciﬁc knowledge of model

internals or training methodologies.

In particular, the incorporation of AI systems into

standard web app development is becoming increas-

ingly universal. For example, many companies in-

corporate chatbot technologies pioneered by services

such as ChatGPT

into their websites in order to as-

sist users interactively (Adamopoulou and Moussi-

ades, 2020). Recent rapid developments in Large

Langauge Model (LLM) technology have allowed

AI-driven chatbots to communicate more naturally

and become useful components of app development

(Brown et al., 2020). Methods of communication in-

https://orcid.org/0009-0002-0098-6343

https://chat.openai.com/

volving customer service representatives are typically

frustrating for users (Parasuraman et al., 1991), either

often requiring long waiting periods on the phone or

for an email response. Chatbots trained in speciﬁc do-

main knowledge can help reduce the volume of com-

munication with human customer service representa-

tives by providing more speciﬁc advice than an FAQ

page in a format tailored to the user’s own knowl-

edge, communication style and language (Nicolescu

and Tudorache, 2022).

Traditional software frameworks are not usually

equipped to facilitate development of AI-driven web

apps. Since the advent and popularity of Ruby

on Rails

, many frameworks in different languages

have followed its example in adopting Model-View-

Controller (MVC) paradigm of software development

as the base of the framework (Laaziri et al., 2019),

with the assumption that models are classes that form

a 1-to-1 relationship with relational database tables;

controllers orchestrate data retrieval of objects de-

rived from one or more models; and views display

this data to users. This paradigm has been an effec-

tive method of software development for many years,

being both ﬂexible enough to support a wide variety

of software apps, and rigid enough that it is easy for

developers to quickly understand, edit and test code.

Unfortunately, this paradigm is often not well suited

to developing AI-driven web apps. These usually de-

https://rubyonrails.org/

450

Fumitake, K., Kishi, S. and Neve, J.

Skeet: Towards a Lightweight Serverless Framework Supporting Modern AI-Driven App Development.

DOI: 10.5220/0012681000003687

Paper published under CC license (CC BY-NC-ND 4.0)

In Proceedings of the 19th International Conference on Evaluation of Novel Approaches to Software Engineering (ENASE 2024), pages 450-457

ISBN: 978-989-758-696-5; ISSN: 2184-4895

pend on faster read/write operations from data sources

such as NoSQL databases (Han et al., 2011) or even

data warehouses such as BigQuery

, which are not al-

ways easy to conform to the MVC convention of ex-

act correspondence between a model and a relational

database table. AI-driven apps also often depend on

cloud infrastructure, communicating with hosted ma-

chine learning resources. Third party libraries can al-

leviate some of these frustrations, but after a certain

point considering alternative paradigms becomes ap-

propriate.

In this paper, we present a novel lightweight Type-

script

framework called Skeet

, which solves these

problems. Skeet is based on development accord-

ing to Domain-Driven Design (Evans, 2004) philoso-

phies: it encourages developers to split their code

into domains which are independent in terms of busi-

ness logic, and provides them with facilities for cloud

deployment with support for multiple datasources,

including relational and NoSQL database reads and

writes. It also incorporates a command-line interface

(CLI) suite which helps developers include popular

pre-trained models such as those from Vertex AI

their apps without requiring speciﬁc domain knowl-

edge. As of January 2024, the framework is increas-

ing in popularity, with 562 Stars on Github and having

been used in a number of small projects.

The novel contributions made by this paper are as

follows:

1. We present design goals for a modern framework

that represent the needs of people whose devel-

opment goals are misaligned with current popular

frameworks, which natively facilitates the incor-

poration of AI and cloud services.

2. We present the architecture of a novel app frame-

work, Skeet, including user-friendly documenta-

tion, which aims to solve these design goals.

3. An initial implementation of this software frame-

work is evaluated using survey data collected

from users who are experienced in traditional soft-

ware frameworks, and have attempted app devel-

opment with Skeet.

2 VISION AND DESIGN GOALS

This section provides an overview of the original mo-

tivations and design goals for Skeet. It contains a re-

view of the state of the art of software frameworks

https://cloud.google.com/bigquery

https://www.typescriptlang.org/

https://github.com/elsoul/skeet-cli

https://cloud.google.com/vertex-ai

including deﬁnition of terminology, the vision for a

modern software framework Skeet, and a set of con-

crete design principles that guided Skeet’s develop-

ment.

2.1 Web Frameworks

This section describes web frameworks conceptually

and provides deﬁnitions of terminology used through-

out this paper.

Web frameworks are suites of tools that facilitate

the development of a web app. Frameworks generally

anticipate that an app will use a particular develop-

ment paradigm (for example MVC) and provide spe-

ciﬁc tools and commands around this. For example,

these tools often include:

• Database management systems, commonly mi-

grations which allow reversible step-by-step

database construction in different environments.

• Object-relational Mapping (ORM) libraries to

facilitate communication with data stores using

code.

• Automatic code and test generation via a Com-

mand Line Interface (CLI) suite for common

tasks.

• Routing libraries to connect speciﬁc subdomains

to executable functions which return HTML or

formatted data such as JSON.

Existing frameworks are in practice classi-

ﬁed along a scale of lightweight to heavyweight.

Lightweight frameworks are minimalist, providing

tools to create an app while allowing the developer

to retain relative freedom of architecture design. An

example of a lightweight framework in Ruby is Sina-

tra

, which provides minimal tools such as routing. A

heavyweight framework often deﬁnes the structure of

the app, and uses assumptions about the developer’s

use of this structure to provide more detailed tools

and commands. For example, Ruby on Rails extends

its tool suite to security, boilerplate code and test gen-

eration and data extraction.

The framework examples above are used to solve

the general problem of constructing a web app. In

the absence of terminology, this paper deﬁnes them as

generalist frameworks. In contrast, specialist frame-

works attempt to solve a problem in a more speciﬁc

domain. For example, e-commerce in the context of

the Semantic Web (Li and Horrocks, 2003) or medical

image processing (Tournier et al., 2019).

https://github.com/sinatra/sinatra

Skeet: Towards a Lightweight Serverless Framework Supporting Modern AI-Driven App Development

451

2.2 The Vision

This section describes the original motivations for the

development of Skeet, which were threefold:

1. Services such as ChatGPT and Vertex AI have

been rising in popularity as a result of devel-

opments in machine learning algorithms and ad-

vances in cloud computing that have made train-

ing large scale models more accessible. Using

these models as a base, construction of speciﬁc

chatbots has become more accessible to a wide

variety of developers. It would be particularly

useful for individual developers to be able to

rapidly construct chatbots from their company’s

data (for example, customer service communica-

tions data from an e-commerce app). A frame-

work is needed which facilitates this through a

simple CLI.

2. There has recently been an expansion in popular-

ity of using strongly typed languages which com-

pile into Javascript to write front-end and back-

end code. For example, Scala.js

and Dart

allow

the compilation of their respective languages into

Javascript. This facilitates communication be-

tween front-end and back-end developers, which

has traditionally been a pain point in organisa-

tions where the two departments may struggle

with scheduling due to lack of understanding of

the other’s development processes. We consider

that Typescript has been popular for a long time

as the base for front-end frameworks such as An-

gularJS

and React

, and is also suitable as a

back-end language. Skeet is intended to provide

a tool suite for both back- and front-end develop-

ers to use Typescript for their development, and

thus reduce the intra-organisational communica-

tion burden.

3. Skeet’s serverless architecture should allow devel-

opers to quickly set up infrastructure without in-

depth knowledge and support scalability. Tradi-

tional development approaches often require up-

front design considerations for load balancing and

resource allocation, which not only lead to higher

design and ﬁxed infrastructure costs but also limit

the application’s ability to scale efﬁciently. The

serverless model is designed to automatically ad-

just to varying loads, enabling not just rapid but

also scalable product development. This adapt-

ability ensures that service owners pay accord-

https://www.scala-js.org/

https://dart.dev/

https://angularjs.org/

https://react.dev/

ing to resource usage, effectively solving long-

standing issues related to infrastructure knowl-

edge, management and cost.

2.3 Design Goals

This section describes concrete design goals of Skeet,

which were distilled from the three overarching mo-

tivations described in section 2.2. As a framework,

Skeet should:

1. Allow full-stack or backend developers to create

apps based on AI chatbots with minimal machine

learning expertise. It should have a command

line interface that allows for the implementation

and ﬁne tuning of various models with relatively

little direct coding on the part of the developer

themselves, allowing them to focus on preparing

the data and building the back end and front end

around the chatbot.

2. Be a lightweight framework. While little ma-

chine learning expertise is assumed, we consider

that a wide variety of apps can be built around

chatbots, and therefore the framework should not

place unnecessary restrictions on the developer.

Skeet does allow and indeed facilitates the use of a

user’s choice of front-end framework such as Re-

act in addition, in order to shape design code.

3. Support cloud infrastructure. Chatbots and other

AI services are often processor- and memory-

intensive technologies that require cloud comput-

ing for training and prediction. Skeet provides a

suite of tools for connecting to popular chatbot

APIs such as ChatGPT and Vertex AI, ﬁne tuning

models and for deploying AI-driven apps directly

on Google Cloud Platform.

4. Facilitate communication between back-end and

front-end developers by reducing the burden of

the language barrier. Skeet assumes a back end

written in Typescript, which is by far the most

popular front-end language thanks to frameworks

such as React, and therefore improves understand-

ing of back-end technologies by front-end devel-

opers including AI-related components.

5. Leverage Serverless Architecture for Scalability

and Cost-Efﬁciency. Skeet’s serverless framework

eliminates the need for upfront infrastructure de-

sign, thereby reducing both time and cost. This

serverless model inherently supports scalability,

automatically adjusting to varying loads without

requiring manual intervention. This not only en-

ables rapid and scalable product development but

also allows for a pay-as-you-go approach to re-

source usage. The serverless architecture makes it

ENASE 2024 - 19th International Conference on Evaluation of Novel Approaches to Software Engineering

452

feasible for small teams or even individual devel-

opers to build and scale applications without the

complexities of traditional infrastructure manage-

ment.

3 FRAMEWORK DESIGN

This section introduces the architecture of the Skeet

framework. It describes how the concepts introduced

in the previous sections are used in terms of concrete

implementation.

3.1 Cloud Infrastructure Architecture

Figure 1 shows the overall structure of the Skeet in-

frastructure architecture. As outlined in Section 1,

the framework is designed around the assumption that

GCP will be used for infrastructure, which allows

communication between the backend and infrastruc-

ture to be handled by the framework code and CLI

commands, simplifying the process for users and es-

pecially developers who are specialised in coding but

less so in infrastructure design.

The architecture assumes a general use app which

requires a front end, back end and data storage. The

overall architecture is designed with the suggested

best practices of Statelessness and Immutability

The architecture incorporates appropriate data

storage, with structured data in a Cloud SQL instance,

unstructured data accessible directly to the front end

stored in a NoSQL database and BigQuery used as

a data warehouse for analysis purposes. These in-

stances are automatically set up as part of the Skeet

initialization process, but these steps can be omitted

if the user desires to design their own cloud architec-

ture.

Conﬁguration parameters for database settings are

deﬁned by internal variables which are stored as Fire-

abse Secrets when they are initiated. Users have the

option to modify these conﬁguration parameters man-

ually, giving them ﬁne-grained control over their in-

frastructure.

The workﬂow of a typical Skeet app as shown in

Figure 1 is as follows. The client communicates with

a frontend which is either a mobile app or a web-

site. The main frameworks recommended by Skeet

and supported at the CLI generator level are React

and React Native

, but other frontends can be used if

https://cloud.google.com/architecture/best-practices-

for-operating-containers#immutability

https://react.dev/

https://reactnative.dev/

the user has particular preferences. The frontend com-

municates directly with Firestore in order to rapidly

access data authorized for the user based on Firebase

data is required, the front end accesses the back end

via a load balancer. Back-end logic is expected to be

hosted as a series of independent functions on Cloud

Functions

AI services are accessed via business logic stored

on Cloud Functions. Popular LLM-based chatbots

such as OpenAI and Vertex AI can be accessed by

registering API keys with the framework. The frame-

work code automates API access and provides CLI

code generators to quickly output the Typescript code

required.

3.2 Back-End Architecture

Back-end code in a Skeet app is divided into Func-

tions. As a general rule, the ﬂow of execution of back

end code is as follows:

1. The frontend calls a Skeet function as an HTTP

request.

2. The function retrieves data from data sources, po-

tentially including relational and NoSQL data and

responses from AI resources.

3. The function performs business logic operations

on the data, re-formats it for displayability and re-

turns it as a JSON response.

A Skeet app can have any number of functions,

and users are encouraged to design ﬁne-grained func-

tions which separate business logic, following SOLID

design principles (Martin, 2000) and in particular the

Single Responsibility principle, which states that each

class should solve only one problem; broadly speak-

ing the same can be said of a Skeet function within the

broader context of domain logic.

A new function can be generated by a CLI com-

mand skeet add functions --name with initial con-

ﬁguration ﬁles and an src directory for user-written

code. A function is initialised with the following di-

rectories:

• lib directory contains classes that perform busi-

ness logic operations on data.

• routings directory provides HTTP endpoints

which can be called by the front end to retrieve

or mutate data.

• scripts directory contains code which executes

scheduled operations independent of the HTTP

endpoints.

• types directory contains data storage classes re-

lated to front-end logic. Data from the database is

Skeet: Towards a Lightweight Serverless Framework Supporting Modern AI-Driven App Development

453

Figure 1: An overview of the Skeet infrastructure architecture.

reorganised from models into types before being

returned.

Users can create blank functions for their own

code, or they can create pre-build functions with scaf-

folding for the purposes of using AI tools such as

chatbots. In the future, community users will be able

to design pre-built functions that anyone can add to

their project.

In addition to domain-speciﬁc code which is

cleanly separated into functions, Skeet also provides

a common directory for cross-function code. This

is deployed independently, can be accessed from all

functions, and includes the following:

• models directory provides data storage classes

that correspond to units of structured data, such

as relational database tables. It is likely that inde-

pendent pieces of domain logic will require data

from the same sources.

• utils directory contains code that executes com-

mon operations across business logic. This is in-

tended for small, repeated functions that are inde-

pendent of domain logic.

• enums directory contains domain-independent

variable deﬁnitions.

The Skeet CLI expects that users will organise

their apps using this broad structure, and provides

commands to generate scaffolding and tests under this

assumption. However, as a lightweight framework, it

does not enforce this structure as such; users are free

to decide their own directory structure, and the frame-

work will still function with the exception of the au-

tomatic code generation functions from the CLI.

3.3 Skeet AI

A key feature of Skeet is the tools that facilitate in-

corporating AI and in particular chatbot features into

web and mobile apps. Machine learning models are

often difﬁcult for developers to understand from ﬁrst

principles, and training and deploying original mod-

els requires considerable specialist knowledge in ad-

dition to, depending on the model and data, signiﬁcant

expenditure on computing resources.

Skeet provides internal libraries and code scaffold-

ing CLI commands for connecting to common AI ser-

vices such as ChatGPT and Vertex AI such that users

only have to input their API credentials in order to

connect to and employ models in their apps.

In addition to back-end code scaffolding and end-

point generation, Skeet also provides front-end re-

sources to help users speciﬁcally with chatbot setup.

Chatbot implementation can be time-consuming to

implement for front-end developers. Skeet provides

front-end commands to assist with this process, so

users can set up pre-trained or ﬁne tuned implementa-

tions with minimal manual code entry.

Finally, Skeet uses pretrained models to assist in

automatic code generation. Employing the Prisma

ORM, it allows users to deﬁne their database tables

using natural language, and converts them to migra-

tions and model ﬁles automatically.

4 EVALUATION

This section describes the evaluation of an initial im-

plementation of Skeet based on the design goals out-

lined in Section 2.3.

https://www.prisma.io/

ENASE 2024 - 19th International Conference on Evaluation of Novel Approaches to Software Engineering

454

4.1 Survey Design

An initial evaluation for the framework was con-

ducted based on survey data collected to identify its

successes and ﬁx potential ﬂaws. The framework is

still in development, and this survey therefore repre-

sents a snapshot of early adopters, and is not intended

as a rigorous and unbiased evaluation, which will be

conducted when development is completed. The ob-

jectives of the survey were threefold:

1. To establish the extent to which the initial release

of Skeet achieves the design goals outlined in Sec-

tion 2.3.

2. To ﬁnd out what kind of developers the framework

currently appeals to.

3. To identify current issues and pain points for de-

velopers using the framework so they can be ﬁxed.

Survey questions were designed with these goals

in mind. The questions can be split into two cat-

egories: questions to gather information about the

participant, and questions to evaluate the framework.

Where possible, questions were asked with answers

on a Likert Scale (Nemoto and Beglar, 2014) from

1-5, which provides a quantitative measurement of

the results, with two positive responses, a neutral re-

sponse and two negative responses.

Information gathering questions were asked with

the objective of tailoring future development and bet-

ter understanding the participants’ evaluative ques-

tions. These are listed below, with possible answers

in brackets where answers were not free choice:

1. Did you complete the tutorial and create a sample

project using Skeet? (Yes / No)

2. Which programming languages do you have ex-

perience with? (Checkbox Selection)

3. Which web frameworks do you have experience

with? (Checkbox Selection)

4. How experienced are you with AI technologies?

(Professional experience / Quite experienced /

Some experience / Inexperienced / No experience)

5. How experienced are you with setting up cloud ar-

chitectures? (Professional experience / Quite ex-

perienced / Some experience / Inexperienced / No

experience)

Evaluation questions were asked with the objec-

tive of ﬁnding out participants’ satisfaction with the

framework as compared to other frameworks, and

identifying speciﬁc pain points that they may have ex-

perienced. The questions with available answers in

brackets are listed below.

6. How easy was it to create and run a new project

in Skeet compared to other frameworks? (Very

easy / Quite easy / Average / Quite difﬁcult / Very

difﬁcult)

7. Compared to other frameworks you’ve used in the

past, how easy was it to create a chatbot using

Skeet? (Very easy / Quite easy / Average / Quite

difﬁcult / Very difﬁcult)

8. Compared to other frameworks, how easy was

it to understand the code architecture of Skeet?

(Very easy / Quite easy / Average / Quite difﬁcult

/ Very difﬁcult)

9. How easy was it to set up GCP services using

Skeet’s CLI compared to the time taken to do it

manually? (Very easy / Quite easy / Average /

Quite difﬁcult / Very difﬁcult)

10. How likely are you to consider using Skeet for a

future project? (Very likely / Quite likely / Possi-

ble / Unlikely / Very unlikely)

The survey also asked for qualitative comments

from participants about the framework, with the fol-

lowing question: ”Please write any comments you

have about your experience using Skeet below”. The

survey was conducted on Google Forms, and col-

lected email addresses but no other identifying infor-

mation from participants. All quantitative responses

were mandatory, and qualitative responses were op-

tional.

4.2 Results

136 participants responded to the online survey, ad-

vertised on X (formerly Twitter), on the Discord for

the framework’s development and on the website for

the framework. Percentages in the text of this section

are rounded to the nearest whole number.

The development experience of users was diverse,

but answers indicated that most respondents came

from a web development background. Most com-

monly (question 2), users had experience develop-

ing in Python (62%), Javascript (58%) and Typescript

(47%). Framework experience (question 3) was sim-

ilar, with ReactJS (51%), Ruby on Rails (41%) and

Angular (37%) being signiﬁcantly higher than other

choices.

Questions 4 and 5 asked about users’ previous ex-

perience with technologies outside of strictly devel-

opment. Experience with AI development was of par-

ticular note, shown in Figure 2: 64% of users ex-

pressed at least some experience, with 13% having

professional experience, which is larger than we an-

ticipated given that the original objective of Skeet is

to assist developers who have very little experience

Skeet: Towards a Lightweight Serverless Framework Supporting Modern AI-Driven App Development

455

Figure 2: Question 4 - How experienced are you with AI

technologies?

with AI technologies. Experience with cloud archi-

tectures showed a similar distribution, with a slightly

higher level of general experience: 68% with at least

some experience or more, 17% with professional ex-

perience. This is not unsurprising, as cloud deploy-

ment is relatively common in the web development

space. Both results, however, are slightly higher than

originally anticipated, and possibly reﬂect the fact

that early adopters of a framework are more likely

to be experienced developers. Further user inter-

views focused speciﬁcally on an inexperienced audi-

ence might be illuminating.

92% of users who submitted the survey were able

to complete the tutorial (question 1). This indicates a

high level of reliability across a wide variety of dif-

ferent development environments. One user who was

not able to complete the tutorial submitted the error

they encountered as a comment, which implied that

mistakenly skipping steps in the tutorial was a possi-

ble reason users were unable to complete it. In order

to address this, the steps that appear to be commonly

skipped will be further emphasised in the tutorial, and

error messages will be updated to indicate to users

when steps might have been missed, and what should

be done to correct this.

Figure 3: Question 6 - How easy was it to create and run a

new project in Skeet compared to other frameworks?

92% of users who were able to complete the tu-

torial responded that being able to create and run a

new project in Skeet (question 6) was average or eas-

ier than average, with 32% answering that it was very

easy (Figure 3). This is an encouraging distribution,

as it indicates that a signiﬁcant percentage of users

who were inexperienced or have no experience with

AI and cloud technologies found it quite easy or very

easy, which was the original objective of framework

development.

Figure 4: Question 8 - Compared to other frameworks

you’ve used in the past, how easy was it to create a chat-

bot using Skeet?

Distributions for questions 8 and 9 were similarly

skewed towards the positive end of the spectrum. 69%

of users indicated that it was either quite or very easy

to create a chatbot using Skeet compared to other

frameworks (Figure 4) and 72% said the same thing

about their experience setting up cloud services in

question 9.

Qualitative results were similarly encouraging. 14

comments were submitted, of which 12 were positive

but nonspeciﬁc (for example, “The speed of develop-

ment and support is fast, which is helpful for develop-

ers.”). One criticism submitted the error they encoun-

tered during the tutorial which, as discussed higher

up in this section, came from skipping a tutorial step.

The other criticism stated, “It was difﬁcult for begin-

ners”. The implication here is unclear, but Skeet is

not designed for complete beginners to programming,

so this user’s experience may not be inconsistent with

the design goals.

These results indicate that this early version of

Skeet is effectively solving the design goals outlined

in Section 2.3. Users were consistently able to com-

plete the tutorial, and those that did so indicated that

their experience with the framework was positive, and

they found it easier than other frameworks than they

had used for the speciﬁc purposes of AI and cloud

service integration. When development work is com-

pleted on the framework, more rigorous surveys will

be conducted examining all aspects of the frame-

work’s ease of use.

5 CONCLUSIONS

Our position is that many of the popular frameworks

currently being used to develop apps were designed

in a previous era, and methods of modern app devel-

opment such as serverless architectures and the use

of tools such as AI are not correctly served by these

frameworks. Where they do provide these features,

they are often added subsequently by third parties

and therefore more difﬁcult to use than those same

features in a framework that had been designed with

ENASE 2024 - 19th International Conference on Evaluation of Novel Approaches to Software Engineering

456

them in mind.

As a potential solution to this problem, this paper

presented a lightweight framework, Skeet. Skeet is

written in Typescript, and allows immediate serverless

deployment upon app creation, regardless of the level

of infrastructure expertise of the user. The frame-

work also allows simple incorporation of AI features

such as chatbots based on pretrained models as CLI-

generated functions. Section 2.3 described speciﬁc

design goals for the framework, and Section 3 de-

scribed how each section of the framework was de-

veloped and therefore achieved the outlined goals.

The framework was initially evaluated through

collecting survey data from users of the framework,

as described in Section 4. This evaluation indicated

that this early version of the framework has been suc-

cessful in achieving its design goals: a vast majority

of the early adopters completed the tutorial, and found

it easier than mainstream alternatives for accomplish-

ing the objectives outlined in the initial design goals.

For web development to continue to progress into

the modern era, and for advanced techniques to con-

tinue to be accessible, we require new frameworks

which allow non-specialist developers to incorporate

these features while hiding some of the complexity

involved in their implementation. Skeet represents an

innovative solution to this problem, and will continue

to be developed with this goal in mind.

ACKNOWLEDGEMENTS

We would like to acknowledge and thank East Ven-

tures, MIRAISE and Rikka for supporting this re-

search project.

REFERENCES

Adamopoulou, E. and Moussiades, L. (2020). An overview

of chatbot technology. In Artiﬁcial Intelligence Ap-

plications and Innovations, pages 373–383. Springer

International Publishing.

Badue, C., Guidolini, R., Carneiro, R. V., Azevedo, P., Car-

doso, V. B., Forechi, A., Jesus, L., Berriel, R., Paix

ao,

T. M., Mutz, F., de Paula Veronese, L., Oliveira-

Santos, T., and De Souza, A. F. (2021). Self-driving

cars: A survey. Expert Systems with Applications,

165:113816.

Brown, T., Mann, B., Ryder, N., Subbiah, M., Kaplan, J. D.,

Dhariwal, P., Neelakantan, A., Shyam, P., Sastry, G.,

Askell, A., et al. (2020). Language models are few-

shot learners. Advances in neural information pro-

cessing systems, 33:1877–1901.

Evans, E. (2004). Domain-driven design: tackling complex-

ity in the heart of software. Addison-Wesley Profes-

sional.

Hamet, P. and Tremblay, J. (2017). Artiﬁcial intelligence in

medicine. Metabolism, 69:S36–S40.

Han, J., Haihong, E., Le, G., and Du, J. (2011). Survey on

nosql database. In 2011 6th international conference

on pervasive computing and applications, pages 363–

366. IEEE.

Laaziri, M., Benmoussa, K., Khoulji, S., and Kerkeb, M.

(2019). A comparative study of php frameworks per-

formance. Procedia Manufacturing, 32:864–871.

Li, L. and Horrocks, I. (2003). A software framework for

matchmaking based on semantic web technology. In

Proceedings of the 12th international conference on

World Wide Web, pages 331–339.

Makridakis, S. (2017). The forthcoming artiﬁcial intelli-

gence (ai) revolution: Its impact on society and ﬁrms.

Futures, 90:46–60.

Martin, R. (2000). Design principles and design patterns.

Nemoto, T. and Beglar, D. (2014). Likert-scale question-

naires. In JALT 2013 conference proceedings, pages

1–8.

Nicolescu, L. and Tudorache, M. (2022). Human-computer

interaction in customer service: the experience with ai

chatbots—a systematic literature review. Electronics,

11(10):1579.

Parasuraman, A., Berry, L., and Zeithaml, V. (1991). Under-

standing customer expectations of service. MIT sloan

management review.

Tournier, J.-D., Smith, R., Raffelt, D., Tabbara, R., Dhol-

lander, T., Pietsch, M., Christiaens, D., Jeurissen, B.,

Yeh, C.-H., and Connelly, A. (2019). Mrtrix3: A

fast, ﬂexible and open software framework for med-

ical image processing and visualisation. Neuroimage,

202:116137.

Skeet: Towards a Lightweight Serverless Framework Supporting Modern AI-Driven App Development

457